ruby-minigraph 0.0.20.0

data/ext/minigraph/bseq.c

@@ -0,0 +1,133 @@
+#include <zlib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#define __STDC_LIMIT_MACROS
+#include "bseq.h"
+#include "kvec-km.h"
+#include "kseq.h"
+KSEQ_INIT(gzFile, gzread)
+
+#define CHECK_PAIR_THRES 1000000
+
+struct mg_bseq_file_s {
+	gzFile fp;
+	kseq_t *ks;
+	mg_bseq1_t s;
+};
+
+mg_bseq_file_t *mg_bseq_open(const char *fn)
+{
+	mg_bseq_file_t *fp;
+	gzFile f;
+	f = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(0, "r");
+	if (f == 0) return 0;
+	fp = (mg_bseq_file_t*)calloc(1, sizeof(mg_bseq_file_t));
+	fp->fp = f;
+	fp->ks = kseq_init(fp->fp);
+	return fp;
+}
+
+void mg_bseq_close(mg_bseq_file_t *fp)
+{
+	kseq_destroy(fp->ks);
+	gzclose(fp->fp);
+	free(fp);
+}
+
+static inline char *kstrdup(const kstring_t *s)
+{
+	char *t;
+	t = (char*)malloc(s->l + 1);
+	memcpy(t, s->s, s->l + 1);
+	return t;
+}
+
+static inline void kseq2bseq(kseq_t *ks, mg_bseq1_t *s, int with_qual, int with_comment)
+{
+	int i;
+	if (ks->name.l == 0)
+		fprintf(stderr, "[WARNING]\033[1;31m empty sequence name in the input.\033[0m\n");
+	s->name = kstrdup(&ks->name);
+	s->seq = kstrdup(&ks->seq);
+	for (i = 0; i < (int)ks->seq.l; ++i) // convert U to T
+		if (s->seq[i] == 'u' || s->seq[i] == 'U')
+			--s->seq[i];
+	s->qual = with_qual && ks->qual.l? kstrdup(&ks->qual) : 0;
+	s->comment = with_comment && ks->comment.l? kstrdup(&ks->comment) : 0;
+	s->l_seq = ks->seq.l;
+}
+
+mg_bseq1_t *mg_bseq_read(mg_bseq_file_t *fp, int64_t chunk_size, int with_qual, int with_comment, int frag_mode, int *n_)
+{
+	int64_t size = 0;
+	int ret;
+	kvec_t(mg_bseq1_t) a = {0,0,0};
+	kseq_t *ks = fp->ks;
+	*n_ = 0;
+	if (fp->s.seq) {
+		kv_resize(mg_bseq1_t, 0, a, 256);
+		kv_push(mg_bseq1_t, 0, a, fp->s);
+		size = fp->s.l_seq;
+		memset(&fp->s, 0, sizeof(mg_bseq1_t));
+	}
+	while ((ret = kseq_read(ks)) >= 0) {
+		mg_bseq1_t *s;
+		assert(ks->seq.l <= INT32_MAX);
+		if (a.m == 0) kv_resize(mg_bseq1_t, 0, a, 256);
+		kv_pushp(mg_bseq1_t, 0, a, &s);
+		kseq2bseq(ks, s, with_qual, with_comment);
+		size += s->l_seq;
+		if (size >= chunk_size) {
+			if (frag_mode && a.a[a.n-1].l_seq < CHECK_PAIR_THRES) {
+				while (kseq_read(ks) >= 0) {
+					kseq2bseq(ks, &fp->s, with_qual, with_comment);
+					if (mg_qname_same(fp->s.name, a.a[a.n-1].name)) {
+						kv_push(mg_bseq1_t, 0, a, fp->s);
+						memset(&fp->s, 0, sizeof(mg_bseq1_t));
+					} else break;
+				}
+			}
+			break;
+		}
+	}
+	if (ret < -1)
+		fprintf(stderr, "[WARNING]\033[1;31m wrong FASTA/FASTQ record. Continue anyway.\033[0m\n");
+	*n_ = a.n;
+	return a.a;
+}
+
+mg_bseq1_t *mg_bseq_read_frag(int n_fp, mg_bseq_file_t **fp, int64_t chunk_size, int with_qual, int with_comment, int *n_)
+{
+	int i;
+	int64_t size = 0;
+	kvec_t(mg_bseq1_t) a = {0,0,0};
+	*n_ = 0;
+	if (n_fp < 1) return 0;
+	while (1) {
+		int n_read = 0;
+		for (i = 0; i < n_fp; ++i)
+			if (kseq_read(fp[i]->ks) >= 0)
+				++n_read;
+		if (n_read < n_fp) {
+			if (n_read > 0)
+				fprintf(stderr, "[W::%s]\033[1;31m query files have different number of records; extra records skipped.\033[0m\n", __func__);
+			break; // some file reaches the end
+		}
+		if (a.m == 0) kv_resize(mg_bseq1_t, 0, a, 256);
+		for (i = 0; i < n_fp; ++i) {
+			mg_bseq1_t *s;
+			kv_pushp(mg_bseq1_t, 0, a, &s);
+			kseq2bseq(fp[i]->ks, s, with_qual, with_comment);
+			size += s->l_seq;
+		}
+		if (size >= chunk_size) break;
+	}
+	*n_ = a.n;
+	return a.a;
+}
+
+int mg_bseq_eof(mg_bseq_file_t *fp)
+{
+	return (ks_eof(fp->ks->f) && fp->s.seq == 0);
+}

data/ext/minigraph/bseq.h

@@ -0,0 +1,76 @@
+#ifndef MM_BSEQ_H
+#define MM_BSEQ_H
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern unsigned char gfa_comp_table[256];
+
+struct mg_bseq_file_s;
+typedef struct mg_bseq_file_s mg_bseq_file_t;
+
+typedef struct {
+	int32_t l_seq, rid;
+	char *name, *seq, *qual, *comment;
+} mg_bseq1_t;
+
+mg_bseq_file_t *mg_bseq_open(const char *fn);
+void mg_bseq_close(mg_bseq_file_t *fp);
+mg_bseq1_t *mg_bseq_read(mg_bseq_file_t *fp, int64_t chunk_size, int with_qual, int with_comment, int frag_mode, int *n_);
+mg_bseq1_t *mg_bseq_read_frag(int n_fp, mg_bseq_file_t **fp, int64_t chunk_size, int with_qual, int with_comment, int *n_);
+int mg_bseq_eof(mg_bseq_file_t *fp);
+
+extern unsigned char seq_nt4_table[256];
+extern unsigned char gfa_comp_table[256];
+
+static inline int32_t mg_qname_len(const char *s)
+{
+	int32_t l;
+	l = strlen(s);
+	return l >= 3 && s[l-1] >= '0' && s[l-1] <= '9' && s[l-2] == '/'? l - 2 : l;
+}
+
+static inline int32_t mg_qname_same(const char *s1, const char *s2)
+{
+	int32_t l1, l2;
+	l1 = mg_qname_len(s1);
+	l2 = mg_qname_len(s2);
+	return (l1 == l2 && strncmp(s1, s2, l1) == 0);
+}
+
+static inline void mg_toupper(int32_t len, char *seq)
+{
+	int32_t j;
+	for (j = 0; j < len; ++j)
+		seq[j] = seq[j] < 'a' || seq[j] > 'z'? seq[j] : seq[j] - 32;
+}
+
+static inline void mg_revcomp_seq(int32_t len, char *seq)
+{
+	int32_t i;
+	for (i = 0; i < len>>1; ++i) {
+		int32_t t = seq[len - i - 1];
+		seq[len - i - 1] = gfa_comp_table[(uint8_t)seq[i]];
+		seq[i] = gfa_comp_table[t];
+	}
+	if (len&1) seq[len>>1] = gfa_comp_table[(uint8_t)seq[len>>1]];
+}
+
+static inline void mg_revcomp_bseq(mg_bseq1_t *s)
+{
+	int32_t i, t, l = s->l_seq;
+	mg_revcomp_seq(s->l_seq, s->seq);
+	if (s->qual)
+		for (i = 0; i < l>>1; ++i)
+			t = s->qual[l - i - 1], s->qual[l - i - 1] = s->qual[i], s->qual[i] = t;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/minigraph/cal_cov.c

@@ -0,0 +1,139 @@
+#include <assert.h>
+#include <string.h>
+#include "mgpriv.h"
+#include "gfa-priv.h"
+#include "algo.h"
+#include "kalloc.h"
+
+void mg_cov_map(const gfa_t *g, const mg_gchains_t *gt, int32_t min_mapq, int32_t min_blen, double *c_seg, double *c_link, const char *qname)
+{
+	int32_t i, j;
+	if (c_seg == 0 && c_link == 0) return;
+	if (gt == 0 || gt->n_gc == 0) return;
+	for (i = 0; i < gt->n_gc; ++i) {
+		const mg_gchain_t *gc = &gt->gc[i];
+		const mg128_t *last_an;
+		assert(gc->cnt > 0 && gc->n_anchor > 0);
+		if (gc->mapq < min_mapq || gc->blen < min_blen) continue;
+		// count segment coverage
+		for (j = 0; j < gc->cnt; ++j) {
+			const mg_llchain_t *lc = &gt->lc[gc->off + j];
+			int32_t s, e;
+			s = 0, e = g->seg[lc->v>>1].len;
+			if (j == 0) s = (int32_t)gt->a[lc->off].x + 1 - (int32_t)(gt->a[lc->off].y>>32&0xff);
+			if (j == gc->cnt - 1) e = (int32_t)gt->a[lc->off + lc->cnt - 1].x + 1;
+			if (c_seg) c_seg[lc->v>>1] += (double)(e - s) / g->seg[lc->v>>1].len;
+		}
+		// count link
+		assert(gt->lc[gc->off].cnt > 0);
+		last_an = &gt->a[gt->lc[gc->off].off + gt->lc[gc->off].cnt - 1];
+		for (j = 1; j < gc->cnt; ++j) {
+			const mg_llchain_t *lc0 = &gt->lc[gc->off + j - 1];
+			const mg_llchain_t *lc1 = &gt->lc[gc->off + j];
+			int64_t a01, a10;
+			if (lc1->cnt > 0) {
+				const mg128_t *curr_an = &gt->a[lc1->off];
+				int32_t is_skip = (mg_seg_id(*curr_an) != mg_seg_id(*last_an));
+				last_an = &gt->a[lc1->off + lc1->cnt - 1];
+				if (is_skip) continue;
+			}
+			a01 = gfa_find_arc(g, lc0->v, lc1->v);
+			a10 = gfa_find_arc(g, lc1->v^1, lc0->v^1);
+			if (a01 < 0 || a10 < 0) {
+				if (mg_verbose >= 2)
+					fprintf(stderr, "[W] Multi/disconnected link: %c%s[%d] -> %c%s[%d] (%s, %ld, %ld). Continue anyway!\n",
+							"><"[lc0->v&1], g->seg[lc0->v>>1].name, lc0->v,
+							"><"[lc1->v&1], g->seg[lc1->v>>1].name, lc1->v, qname, (long)a01, (long)a10);
+				continue;
+			}
+			assert((g->arc[a01].comp ^ g->arc[a10].comp) == 1);
+			if (c_link) c_link[a01] += 1.0, c_link[a10] += 1.0;
+		}
+	}
+}
+
+void mg_cov_asm(const gfa_t *g, int32_t n_seq, mg_gchains_t *const *gcs, int32_t min_mapq, int32_t min_blen, double *cov_seg, double *cov_link)
+{
+	int32_t i, j, t, *soff, *scnt, *cnt_link;
+	int64_t k;
+	mg_intv_t *sintv = 0;
+	void *km = 0;
+
+	// precalculate the size of sintv[] for each segment
+	KCALLOC(km, scnt, g->n_seg);
+	for (t = 0; t < n_seq; ++t) {
+		const mg_gchains_t *gt = gcs[t];
+		if (gt == 0 || gt->n_gc == 0) continue;
+		for (i = 0; i < gt->n_gc; ++i) {
+			const mg_gchain_t *gc = &gt->gc[i];
+			assert(gc->cnt > 0 && gc->n_anchor > 0);
+			if (gc->mapq < min_mapq || gc->blen < min_blen) continue;
+			for (j = 0; j < gc->cnt; ++j) {
+				const mg_llchain_t *lc = &gt->lc[gc->off + j];
+				++scnt[lc->v>>1];
+			}
+		}
+	}
+	KMALLOC(km, soff, g->n_seg + 1);
+	for (soff[0] = 0, i = 1; i <= g->n_seg; ++i)
+		soff[i] = soff[i - 1] + scnt[i - 1];
+	memset(scnt, 0, 4 * g->n_seg);
+	KMALLOC(km, sintv, soff[g->n_seg]);
+
+	// fill sintv[]
+	KCALLOC(km, cnt_link, g->n_arc);
+	for (t = 0; t < n_seq; ++t) {
+		const mg_gchains_t *gt = gcs[t];
+		if (gt == 0 || gt->n_gc == 0) continue;
+		for (i = 0; i < gt->n_gc;) {
+			const mg_gchain_t *gc = &gt->gc[i];
+			if (gc->mapq < min_mapq || gc->blen < min_blen) continue;
+			// count segment coverage
+			for (j = 0; j < gc->cnt; ++j) {
+				const mg_llchain_t *lc = &gt->lc[gc->off + j];
+				int32_t s, e, tmp;
+				mg_intv_t *p;
+				s = 0, e = g->seg[lc->v>>1].len;
+				if (j == 0) s = (int32_t)gt->a[lc->off].x + 1 - (int32_t)(gt->a[lc->off].y>>32&0xff);
+				if (j == gc->cnt - 1) e = (int32_t)gt->a[lc->off + lc->cnt - 1].x + 1;
+				if (lc->v&1) // convert to the forward strand of segment lc->v>>1
+					tmp = g->seg[lc->v>>1].len - s, s = g->seg[lc->v>>1].len - e, e = tmp;
+				p = &sintv[soff[lc->v>>1] + scnt[lc->v>>1]];
+				++scnt[lc->v>>1];
+				p->st = s, p->en = e, p->rev = lc->v&1, p->far = -1, p->i = -1;
+			}
+			// count link
+			for (j = 1; j < gc->cnt; ++j) {
+				const mg_llchain_t *lc0 = &gt->lc[gc->off + j - 1];
+				const mg_llchain_t *lc1 = &gt->lc[gc->off + j];
+				int64_t a01, a10;
+				a01 = gfa_find_arc(g, lc0->v, lc1->v);
+				a10 = gfa_find_arc(g, lc1->v^1, lc0->v^1);
+				assert(a01 >= 0 && a10 >= 0);
+				assert((g->arc[a01].comp ^ g->arc[a10].comp) == 1);
+				++cnt_link[a01];
+				++cnt_link[a10];
+			}
+		}
+	}
+
+	// update cov_link[] and cov_seg[]
+	for (k = 0; k < g->n_arc; ++k)
+		if (cnt_link[k] > 0) cov_link[k] += 1.0;
+	for (i = 0; i < g->n_seg; ++i) {
+		int32_t st = 0, en = 0, cov = 0;
+		assert(scnt[i] == soff[i+1] - soff[i]);
+		radix_sort_mg_intv(&sintv[soff[i]], &sintv[soff[i+1]]);
+		for (j = soff[i]; j < soff[i+1]; ++j) {
+			if (sintv[j].st > en)
+				cov += en - st, st = sintv[j].st, en = sintv[j].en;
+			else en = sintv[j].en > en? sintv[j].en : en;
+		}
+		cov += en - st;
+		cov_seg[i] += (double)cov / g->seg[i].len;
+	}
+
+	// free
+	kfree(km, cnt_link);
+	kfree(km, sintv); kfree(km, soff); kfree(km, scnt);
+}

data/ext/minigraph/format.c

@@ -0,0 +1,241 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+#include <math.h>
+#include "kalloc.h"
+#include "mgpriv.h"
+
+static inline void str_enlarge(kstring_t *s, int l)
+{
+	if (s->l + l + 1 > s->m) {
+		s->m = s->l + l + 1;
+		kroundup32(s->m);
+		s->s = (char*)realloc(s->s, s->m);
+	}
+}
+
+static inline void str_copy(kstring_t *s, const char *st, const char *en)
+{
+	str_enlarge(s, en - st);
+	memcpy(&s->s[s->l], st, en - st);
+	s->l += en - st;
+}
+
+void mg_sprintf_lite(kstring_t *s, const char *fmt, ...)
+{
+	char buf[16]; // for integer to string conversion
+	const char *p, *q;
+	va_list ap;
+	va_start(ap, fmt);
+	for (q = p = fmt; *p; ++p) {
+		if (*p == '%') {
+			if (p > q) str_copy(s, q, p);
+			++p;
+			if (*p == 'd') {
+				int c, i, l = 0;
+				unsigned int x;
+				c = va_arg(ap, int);
+				x = c >= 0? c : -c;
+				do { buf[l++] = x%10 + '0'; x /= 10; } while (x > 0);
+				if (c < 0) buf[l++] = '-';
+				str_enlarge(s, l);
+				for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
+			} else if (*p == 'u') {
+				int i, l = 0;
+				uint32_t x;
+				x = va_arg(ap, uint32_t);
+				do { buf[l++] = x%10 + '0'; x /= 10; } while (x > 0);
+				str_enlarge(s, l);
+				for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
+			} else if (*p == 's') {
+				char *r = va_arg(ap, char*);
+				str_copy(s, r, r + strlen(r));
+			} else if (*p == 'c') {
+				str_enlarge(s, 1);
+				s->s[s->l++] = va_arg(ap, int);
+			} else abort();
+			q = p + 1;
+		}
+	}
+	if (p > q) str_copy(s, q, p);
+	va_end(ap);
+	s->s[s->l] = 0;
+}
+
+void mg_print_lchain(FILE *fp, const mg_idx_t *gi, int n_lc, const mg_lchain_t *lc, const mg128_t *a, const char *qname)
+{
+	kstring_t str = {0,0,0};
+	int i, j;
+	for (i = 0; i < n_lc; ++i) {
+		const mg_lchain_t *p = &lc[i];
+		int mlen, blen, span = a[p->off].y>>32&0xff;
+		mlen = blen = span;
+		for (j = 1; j < p->cnt; ++j) {
+			int ql = (int32_t)a[p->off + j].y - (int32_t)a[p->off + j - 1].y;
+			int pl = (int32_t)a[p->off + j].x - (int32_t)a[p->off + j - 1].x;
+			blen += pl > ql? pl : ql;
+			mlen += pl > span && ql > span? span : pl < ql? pl : ql;
+		}
+		str.l = 0;
+		mg_sprintf_lite(&str, "LC\t%s\t%d\t%d\t%c\t%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t", qname, p->qs, p->qe, "+-"[p->v&1], gi->g->seg[p->v>>1].name, gi->g->seg[p->v>>1].len,
+						p->rs, p->re, p->score, mlen, blen, p->cnt);
+		for (j = 0; j < p->cnt; ++j)
+			mg_sprintf_lite(&str, "%d,", (int32_t)a[p->off + j].y);
+		mg_sprintf_lite(&str, "\t");
+		for (j = 0; j < p->cnt; ++j)
+			mg_sprintf_lite(&str, "%d,", (int32_t)a[p->off + j].x);
+		mg_sprintf_lite(&str, "\t");
+		for (j = 0; j < p->cnt; ++j)
+			mg_sprintf_lite(&str, "%d,", (int32_t)(a[p->off + j].y>>MG_SEED_OCC_SHIFT));
+		mg_sprintf_lite(&str, "\n");
+		fwrite(str.s, 1, str.l, fp);
+	}
+	free(str.s);
+}
+
+void mg_write_gaf(kstring_t *s, const gfa_t *g, const mg_gchains_t *gs, int32_t n_seg, const int32_t *qlens, const char *qname, uint64_t flag, void *km)
+{
+	int32_t i, j, qlen, rev_sign = 0;
+	s->l = 0;
+	for (i = 0, qlen = 0; i < n_seg; ++i) qlen += qlens[i];
+	if ((gs == 0 || gs->n_gc == 0) && (flag&MG_M_SHOW_UNMAP)) {
+		mg_sprintf_lite(s, "%s", qname);
+		if ((flag&MG_M_FRAG_MERGE) && n_seg == 2 && s->l > 2 && s->s[s->l-1] == '1' && s->s[s->l-2] == '/') s->l -= 2;
+		mg_sprintf_lite(s, "\t%d\t0\t0\t*\t*\t0\t0\t0\t0\t0\t0\n", qlen);
+		return;
+	}
+	if (gs == 0) return;
+	for (i = 0; i < gs->n_gc; ++i) {
+		const mg_gchain_t *p = &gs->gc[i];
+		int32_t sign_pos, compact;
+		if (p->id != p->parent && !(flag&MG_M_PRINT_2ND)) continue;
+		if (p->cnt == 0) continue;
+		mg_sprintf_lite(s, "%s", qname);
+		if ((flag&MG_M_FRAG_MERGE) && n_seg == 2 && s->l > 2 && s->s[s->l-1] == '1' && s->s[s->l-2] == '/') s->l -= 2;
+		mg_sprintf_lite(s, "\t%d\t%d\t%d\t+\t", qlen, p->qs, p->qe);
+		assert(p->cnt > 0);
+		sign_pos = s->l - 2;
+		if (flag & MG_M_VERTEX_COOR) {
+			compact = 0;
+			for (j = 0; j < p->cnt; ++j) {
+				const mg_llchain_t *q = &gs->lc[p->off + j];
+				mg_sprintf_lite(s, "%c%s", "><"[q->v&1], g->seg[q->v>>1].name);
+			}
+		} else {
+			int32_t last_pnid = -1, st = -1, en = -1, rev = -1;
+			compact = flag&MG_M_NO_COMP_PATH? 0 : 1;
+			for (j = 0; j < p->cnt; ++j) {
+				const mg_llchain_t *q;
+				const gfa_seg_t *t;
+				assert(p->off + j < gs->n_lc);
+				q = &gs->lc[p->off + j];
+				t = &g->seg[q->v>>1];
+				if (t->snid < 0) { // no stable ID; write the vertex coordinate
+					compact = 0;
+					if (last_pnid >= 0) mg_sprintf_lite(s, "%c%s:%d-%d", "><"[rev], g->sseq[last_pnid].name, st, en);
+					last_pnid = -1, st = -1, en = -1, rev = -1;
+					mg_sprintf_lite(s, "%c%s", "><"[q->v&1], g->seg[q->v>>1].name);
+				} else {
+					int cont = 0;
+					if (last_pnid >= 0 && t->snid == last_pnid && (q->v&1) == rev) { // same stable sequence and same strand
+						if (!(q->v&1)) { // forward strand
+							if (t->soff == en)
+								en = t->soff + t->len, cont = 1;
+						} else { // reverse strand
+							if (t->soff + t->len == st)
+								st = t->soff, cont = 1;
+						}
+					}
+					if (cont == 0) {
+						if (last_pnid >= 0) compact = 0;
+						if (last_pnid >= 0) mg_sprintf_lite(s, "%c%s:%d-%d", "><"[rev], g->sseq[last_pnid].name, st, en);
+						last_pnid = t->snid, rev = q->v&1, st = t->soff, en = st + t->len;
+					}
+				}
+			}
+			if (last_pnid >= 0) {
+				if (g->sseq[last_pnid].rank != 0 || g->sseq[last_pnid].min != 0)
+					compact = 0;
+				if (!compact) mg_sprintf_lite(s, "%c%s:%d-%d", "><"[rev], g->sseq[last_pnid].name, st, en);
+			} else compact = 0;
+		}
+		if (compact) {
+			int32_t rev = gs->lc[p->off].v&1;
+			const gfa_seg_t *t = &g->seg[gs->lc[rev? p->off + p->cnt - 1 : p->off].v>>1];
+			const gfa_sseq_t *ps = &g->sseq[t->snid];
+			mg_sprintf_lite(s, "%s\t%d\t", ps->name, ps->max);
+			if (rev) {
+				rev_sign = 1;
+				s->s[sign_pos] = '-';
+				mg_sprintf_lite(s, "%d\t%d", t->soff + (p->plen - p->pe), t->soff + (p->plen - p->ps));
+			} else {
+				mg_sprintf_lite(s, "%d\t%d", t->soff + p->ps, t->soff + p->pe);
+			}
+		} else mg_sprintf_lite(s, "\t%d\t%d\t%d", p->plen, p->ps, p->pe);
+		if (p->p) mg_sprintf_lite(s, "\t%d\t%d\t%d", p->p->mlen, p->p->blen, p->mapq);
+		else mg_sprintf_lite(s, "\t%d\t%d\t%d", p->mlen, p->blen, p->mapq);
+		mg_sprintf_lite(s, "\ttp:A:%c", p->id == p->parent? 'P' : 'S');
+		if (p->p) mg_sprintf_lite(s, "\tNM:i:%d", p->p->blen - p->p->mlen);
+		mg_sprintf_lite(s, "\tcm:i:%d\ts1:i:%d\ts2:i:%d", p->n_anchor, p->score, p->subsc);
+		if (p->div >= 0.0f && p->div <= 1.0f) {
+			char buf[16];
+			if (p->div == 0.0f) buf[0] = '0', buf[1] = 0;
+			else snprintf(buf, 16, "%.4f", p->div);
+			mg_sprintf_lite(s, "\tdv:f:%s", buf);
+		}
+		if (n_seg > 1) {
+			mg_sprintf_lite(s, "\tql:B:i");
+			for (j = 0; j < n_seg; ++j) mg_sprintf_lite(s, ",%d", qlens[j]);
+		}
+		if (p->p) {
+			mg_sprintf_lite(s, "\tcg:Z:");
+			if (rev_sign)
+				for (j = p->p->n_cigar - 1; j >= 0; --j)
+					mg_sprintf_lite(s, "%d%c", (int32_t)(p->p->cigar[j]>>4), "MIDNSHP=XB"[p->p->cigar[j]&0xf]);
+			else
+				for (j = 0; j < p->p->n_cigar; ++j)
+					mg_sprintf_lite(s, "%d%c", (int32_t)(p->p->cigar[j]>>4), "MIDNSHP=XB"[p->p->cigar[j]&0xf]);
+		}
+		mg_sprintf_lite(s, "\n");
+		if ((mg_dbg_flag & MG_DBG_LCHAIN) || (flag & MG_M_WRITE_LCHAIN)) {
+			char buf[16];
+			for (j = 0; j < p->cnt; ++j) {
+				const mg_llchain_t *lc = &gs->lc[p->off + j];
+				mg_sprintf_lite(s, "*\t%c%s\t%d\t%d", "><"[lc->v&1], g->seg[lc->v>>1].name, g->seg[lc->v>>1].len, lc->cnt);
+				if (lc->cnt > 0) {
+					double div;
+					int32_t q_span = (int32_t)(gs->a[lc->off].y>>32&0xff);
+					int32_t n = (int32_t)(gs->a[lc->off + lc->cnt - 1].x>>32) - (int32_t)(gs->a[lc->off].x>>32) + 1;
+					div = n == lc->cnt? 0.0 : (n > lc->cnt? log((double)n / lc->cnt) : log((double)lc->cnt / n)) / q_span;
+					if (div == 0.0) buf[0] = '0', buf[1] = 0;
+					else snprintf(buf, 16, "%.4f", div);
+					mg_sprintf_lite(s, "\t%s", buf);
+					mg_sprintf_lite(s, "\t%d\t%d", (int32_t)gs->a[lc->off].x + 1 - q_span, (int32_t)gs->a[lc->off + lc->cnt - 1].x + 1);
+					mg_sprintf_lite(s, "\t%d\t%d", (int32_t)gs->a[lc->off].y + 1 - q_span, (int32_t)gs->a[lc->off + lc->cnt - 1].y + 1);
+					if (flag & MG_M_WRITE_MZ) {
+						int32_t i, last;
+						last = (int32_t)gs->a[lc->off].x + 1 - q_span;
+						mg_sprintf_lite(s, "\t%d\t", q_span);
+						for (i = 1; i < lc->cnt; ++i) {
+							int32_t x = (int32_t)gs->a[lc->off + i].x + 1 - q_span;
+							if (i > 1) mg_sprintf_lite(s, ",");
+							mg_sprintf_lite(s, "%d", x - last);
+							last = x;
+						}
+						last = (int32_t)gs->a[lc->off].y + 1 - q_span;
+						mg_sprintf_lite(s, "\t");
+						for (i = 1; i < lc->cnt; ++i) {
+							int32_t x = (int32_t)gs->a[lc->off + i].y + 1 - q_span;
+							if (i > 1) mg_sprintf_lite(s, ",");
+							mg_sprintf_lite(s, "%d", x - last);
+							last = x;
+						}
+					}
+				}
+				mg_sprintf_lite(s, "\n");
+			}
+		}
+	}
+}