ruby-minigraph 0.0.20.0

data/ext/minigraph/README.md

@@ -0,0 +1,207 @@
+[![Build Status](https://travis-ci.org/lh3/minigraph.svg?branch=master)](https://travis-ci.org/lh3/minigraph)
+## <a name="started"></a>Getting Started
+
+```sh
+git clone https://github.com/lh3/minigraph
+cd minigraph && make
+# Map sequence to sequence, similar to minimap2 without base alignment
+./minigraph test/MT-human.fa test/MT-orangA.fa > out.paf
+# Map sequence to graph
+./minigraph test/MT.gfa test/MT-orangA.fa > out.gaf
+# Incremental graph generation (-l10k necessary for this toy example)
+./minigraph -cxggs -l10k test/MT.gfa test/MT-chimp.fa test/MT-orangA.fa > out.gfa
+# Call per-sample path in each bubble/variation (-c not needed for this)
+./minigraph -xasm -l10k --call test/MT.gfa test/MT-orangA.fa > orangA.call.bed
+
+# The lossy FASTA representation (requring https://github.com/lh3/gfatools)
+gfatools gfa2fa -s out.gfa > out.fa
+# Extract localized structural variations
+gfatools bubble out.gfa > SV.bed
+```
+
+## Table of Contents
+
+<img align="right" width="278" src="doc/example1.png"/>
+
+- [Getting Started](#started)
+- [Introduction](#intro)
+- [Users' Guide](#uguide)
+  - [Installation](#install)
+  - [Sequence-to-graph mapping](#map)
+  - [Graph generation](#ggen)
+  - [Calling structural variations](#callsv)
+  - [Prebuilt graphs](#prebuilt)
+  - [Algorithm overview](#algo)
+- [Limitations](#limit)
+
+## <a name="intro"></a>Introduction
+
+Minigraph is a sequence-to-graph mapper and graph constructor. For graph
+generation, it aligns a query sequence against a sequence graph and
+incrementally augments an existing graph with long query subsequences diverged
+from the graph. The figure on the right briefly explains the procedure.
+
+Minigraph borrows ideas and code from [minimap2][minimap2]. It is fairly
+efficient and can construct a graph from 90 human assemblies in a couple of
+days using 24 CPU cores. Older versions of minigraph was unable to produce
+base alignment. The latest version can. **Please add option `-c` for graph
+generation** as it generally improves the quality of graphs.
+
+## <a name="uguide"></a>Users' Guide
+
+### <a name="install"></a>Installation
+
+To install minigraph, type `make` in the source code directory. The only
+non-standard dependency is [zlib][zlib]. For better performance, it is
+recommended to compile with recent compliers.
+
+### <a name="map"></a>Sequence-to-graph mapping
+
+To map sequences against a graph, you should prepare the graph in the [GFA
+format][gfa1], or preferrably the [rGFA format][rgfa]. If you don't have
+a graph, you can generate a graph from multiple samples (see the [Graph
+generation section](#ggen) below). The typical command line for mapping is
+```sh
+minigraph -cx lr graph.gfa query.fa > out.gaf
+```
+You may choose the right preset option `-x` according to input. Minigraph
+output mappings in the [GAF format][gaf], which is a strict superset of the
+[PAF format][paf]. The only visual difference between GAF and PAF is that the
+6th column in GAF may encode a graph path like
+`>MT_human:0-4001<MT_orang:3426-3927` instead of a contig/chromosome name.
+
+The minigraph GFA parser seamlessly parses FASTA and converts it to GFA
+internally, so you can also provide sequences in FASTA as the reference. In
+this case, minigraph will behave like minimap2, though likely producing
+different alignments due to differences between the two implementations.
+
+### <a name="ggen"></a>Graph generation
+
+The following command-line generates a graph in rGFA:
+```sh
+minigraph -cxggs -t16 ref.fa sample1.fa sample2.fa > out.gfa
+```
+which is equivalent to
+```sh
+minigraph -cxggs -t16 ref.fa sample1.fa > sample1.gfa
+minigraph -cxggs -t16 sample1.gfa sample2.fa > out.gfa
+```
+File `ref.fa` is typically the reference genome (e.g. GRCh38 for human).
+It can also be replaced by a graph in rGFA. Minigraph assumes `sample1.fa` to
+be the whole-genome assembly of an individual. This is an important assumption:
+minigraph only considers 1-to-1 orthogonal regions between the graph and the
+individual FASTA. If you use raw reads or put multiple individual genomes in
+one file, minigraph will filter out most alignments as they cover the input
+graph multiple times.
+
+The output rGFA can be converted to a FASTA file with [gfatools][gfatools]:
+```sh
+gfatools gfa2fa -s graph.gfa > out.stable.fa
+```
+The output `out.stable.fa` will always include the initial reference `ref.fa`
+and may additionally add new segments diverged from the initial reference.
+
+### <a name="callsv"></a>Calling structural variations
+
+A minigraph graph is composed of chains of bubbles with the reference as the
+backbone. Each *bubble* represents a structural variation. It can be
+multi-allelic if there are multiple paths through the bubble. You can extract
+these bubbles with
+```sh
+gfatools bubble graph.gfa > var.bed
+```
+The output is a BED-like file. The first three columns give the position of a
+bubble/variation and the rest of columns are:
+
+* (4) \# GFA segments in the bubble including the source and the sink of the bubble
+* (5) \# all possible paths through the bubble (not all paths present in input samples)
+* (6) 1 if the bubble involves an inversion; 0 otherwise
+* (7) length of the shortest path (i.e. allele) through the bubble
+* (8) length of the longest path/allele through the bubble
+* (9-11) please ignore
+* (12) list of segments in the bubble; first for the source and last for the sink
+* (13) sequence of the shortest path (`*` if zero length)
+* (14) sequence of the longest path (NB: it may not be present in the input samples)
+
+Given an assembly, you can find the path/allele of this assembly in each bubble with
+```sh
+minigraph -cxasm --call graph.gfa sample-asm.fa > sample.bed
+```
+On each line in the BED-like output, the last colon separated field gives the
+alignment path through the bubble, the path length in the graph, the mapping
+strand of sample contig, the contig name, the approximate contig start and
+contig end. The number of lines in the file is the same as the number of lines
+in the output of `gfatools bubble`. You can use the `paste` Unix command to
+piece multiple samples together.
+
+### <a name="prebuilt"></a>Prebuilt graphs
+
+Prebuilt human graphs in the rGFA format can be found [at Zenodo][human-zenodo].
+
+### <a name="algo"></a>Algorithm overview
+
+<img align="right" width="278" src="doc/example2.png"/>
+
+In the following, minigraph command line options have a dash ahead and are
+highlighted in bold. The description may help to tune minigraph parameters.
+
+1. Read all reference bases, extract (**-k**,**-w**)-minimizers and index them
+   in a hash table.
+
+2. Read **-K** [=*500M*] query bases in the mapping mode, or read all query
+   bases in the graph construction mode. For each query sequence, do step 3
+   through 5:
+
+3. Find colinear minimizer chains using the [minimap2][minimap2] algorithm,
+   assuming segments in the graph are disconnected. These are called *linear
+   chains*.
+
+4. Perform another round of chaining, taking each linear chain as an anchor.
+   For a pair of linear chains, minigraph tries to connect them by doing graph
+   wavefront alignment algorithm (GWFA). If minigraph fails to find an
+   alignment within an edit distance threshold, it will find up to 15 shortest
+   paths between the two linear chains and chooses the path of length closest
+   to the distance on the query sequence. Chains found at this step are called
+   *graph chains*.
+
+5. Identify primary chains and estimate mapping quality with a method similar
+   to the one used in minimap2. Perform base alignment.
+
+6. In the graph construction mode, collect all mappings longer than **-d**
+   [=*10k*] and keep their query and graph segment intervals in two lists,
+   respectively.
+
+7. For each mapping longer than **-l** [=*100k*], finds poorly aligned regions.
+   A region is filtered if it overlaps two or more intervals collected at step
+   6.
+
+8. Insert the remaining poorly aligned regions into the input graph. This
+   constructs a new graph.
+
+## <a name="limit"></a>Limitations
+
+* A complex minigraph subgraph is often suboptimal and may vary with the order
+  of input samples. It may not represent the evolution history
+  or the functional relevance at the locus. Please *do not overinterpret*
+  complex subgraphs. If you are interested in a particular subgraph, it is
+  recommended to extract the input contig subsequences involved in the subgraph
+  with the `--call` option and manually curated the results.
+
+* Minigraph needs to find strong colinear chains first. For a graph consisting
+  of many short segments (e.g. one generated from rare SNPs in large
+  populations), minigraph will fail to map query sequences.
+
+* The base alignment in the current version of minigraph is slow for species of
+  high diversity.
+
+
+[zlib]: http://zlib.net/
+[minimap2]: https://github.com/lh3/minimap2
+[rgfa]: https://github.com/lh3/gfatools/blob/master/doc/rGFA.md
+[gfa1]: https://github.com/GFA-spec/GFA-spec/blob/master/GFA1.md
+[gaf]: https://github.com/lh3/gfatools/blob/master/doc/rGFA.md#the-graph-alignment-format-gaf
+[paf]: https://github.com/lh3/miniasm/blob/master/PAF.md
+[gfatools]: https://github.com/lh3/gfatools
+[bandage]: https://rrwick.github.io/Bandage/
+[gfaviz]: https://github.com/ggonnella/gfaviz
+[human-zenodo]: https://zenodo.org/record/6499594

data/ext/minigraph/algo.c

@@ -0,0 +1,194 @@
+#include <stdlib.h>
+#include <string.h>
+#include "kalloc.h"
+#define __STDC_LIMIT_MACROS
+#include "algo.h"
+#include "miniwfa.h"
+
+/************************
+ * Max-scoring segments *
+ ************************/
+
+#include "kvec-km.h"
+
+#define MSS_NEG_INF INT32_MIN
+
+typedef struct {
+    int32_t st, en;
+    MG_MSS_TYPE L, R;
+    int32_t pre;
+} msseg_aux_t;
+
+typedef kvec_t(mg_msseg_t) msseg_v;
+typedef kvec_t(msseg_aux_t) msseg_aux_v;
+
+static void move_segs(void *km, msseg_v *ret, msseg_aux_v *seg, MG_MSS_TYPE min_sc)
+{
+    int32_t i;
+    for (i = 0; i < seg->n; ++i) {
+        msseg_aux_t *p = &seg->a[i];
+        if (p->R - p->L >= min_sc) {
+            mg_msseg_t *q;
+            kv_pushp(mg_msseg_t, km, *ret, &q);
+            q->st = p->st, q->en = p->en, q->sc = p->R - p->L;
+        }
+    }
+    seg->n = 0;
+}
+
+// Reference: Ruzzo and Tompa (1999) A linear time algorithm for finding all maximal scoring subsequencs
+mg_msseg_t *mg_mss_all(void *km, int32_t n, const MG_MSS_TYPE *S, MG_MSS_TYPE min_sc, MG_MSS_TYPE xdrop, int32_t *n_seg)
+{
+    int32_t i, j;
+    MG_MSS_TYPE L, max;
+    msseg_v ret = {0,0,0};
+    msseg_aux_v seg = {0,0,0};
+    msseg_aux_t t;
+
+	kv_resize(mg_msseg_t, km, ret, 16);
+	kv_resize(msseg_aux_t, km, seg, 16);
+    for (i = 0, L = 0, max = MSS_NEG_INF; i < n;) {
+        if (S[i] > 0) {
+            int32_t k;
+            MG_MSS_TYPE R = L + S[i];
+            for (k = i + 1; k < n && S[k] > 0; ++k)
+                R += S[k];
+			if (R > max) max = R;
+            t.st = i, t.en = k, t.L = L, t.R = R;
+            while (1) {
+                msseg_aux_t *p;
+                for (j = seg.n - 1; j >= 0;) {
+                    p = &seg.a[j];
+                    if (p->L < t.L) break;
+                    j = p->pre >= 0? p->pre : j - 1;
+                }
+                if (j >= 0 && seg.a[j].R < t.R) {
+                    p = &seg.a[j];
+                    t.st = p->st, t.L = p->L, t.pre = p->pre;
+                    seg.n = j;
+                } else {
+                    if (j < 0) {
+						move_segs(km, &ret, &seg, min_sc);
+						max = R;
+					}
+                    t.pre = j;
+                    kv_push(msseg_aux_t, km, seg, t);
+                    break;
+                }
+            }
+            L = R, i = k;
+        } else {
+			if (xdrop > 0 && L + S[i] + xdrop < max) { // reset
+				move_segs(km, &ret, &seg, min_sc);
+				L = 0, max = MSS_NEG_INF;
+			}
+			L += S[i++];
+		}
+    }
+    move_segs(km, &ret, &seg, min_sc);
+    kfree(km, seg.a);
+	KREALLOC(km, ret.a, ret.n);
+    *n_seg = ret.n;
+    return ret.a;
+}
+
+/**************************
+ * Interval overlap query *
+ **************************/
+
+#include <assert.h>
+#include "ksort.h"
+
+#define sort_key_intv(a) ((a).st)
+KRADIX_SORT_INIT(mg_intv, mg_intv_t, sort_key_intv, 4)
+
+int32_t mg_intv_index(int32_t n, mg_intv_t *a)
+{
+	int32_t i, last_i, last, k;
+	if (n <= 0) return -1;
+	radix_sort_mg_intv(a, a + n);
+	for (i = 0; i < n; i += 2) last_i = i, last = a[i].far = a[i].en;
+	for (k = 1; 1LL<<k <= n; ++k) {
+		int64_t x = 1LL<<(k-1), i0 = (x<<1) - 1, step = x<<2;
+		for (i = i0; i < n; i += step) {
+			int32_t el = a[i - x].far;
+			int32_t er = i + x < n? a[i + x].far : last;
+			int32_t e = a[i].en;
+			e = e > el? e : el;
+			e = e > er? e : er;
+			a[i].far = e;
+		}
+		last_i = last_i>>k&1? last_i - x : last_i + x;
+		if (last_i < n && a[last_i].far > last)
+			last = a[last_i].far;
+	}
+	return k - 1;
+}
+
+typedef struct {
+	int64_t x;
+	int32_t k, w;
+} istack_t;
+
+int32_t mg_intv_overlap(void *km, int32_t n_a, const mg_intv_t *a, int32_t st, int32_t en, int32_t **b_, int32_t *m_b_)
+{
+	int32_t t = 0, h, *b = *b_, m_b = *m_b_, n = 0;
+	istack_t stack[64], *p;
+
+	for (h = 0; 1<<h <= n_a; ++h);
+	--h;
+	p = &stack[t++];
+	p->k = h, p->x = (1LL<<p->k) - 1, p->w = 0; // push the root into the stack
+	while (t) { // stack is not empyt
+		istack_t z = stack[--t];
+		if (z.k <= 3) { // the subtree is no larger than (1<<(z.k+1))-1; do a linear scan
+			int32_t i, i0 = z.x >> z.k << z.k, i1 = i0 + (1LL<<(z.k+1)) - 1;
+			if (i1 >= n_a) i1 = n_a;
+			for (i = i0; i < i1 && a[i].st < en; ++i)
+				if (st < a[i].en) {
+					if (n == m_b) KEXPAND(km, b, m_b);
+					b[n++] = i;
+				}
+		} else if (z.w == 0) { // if left child not processed
+			int32_t y = z.x - (1LL<<(z.k-1));
+			p = &stack[t++];
+			p->k = z.k, p->x = z.x, p->w = 1;
+			if (y >= n_a || a[y].far > st) {
+				p = &stack[t++];
+				p->k = z.k - 1, p->x = y, p->w = 0; // push the left child to the stack
+			}
+		} else if (z.x < n_a && a[z.x].st < en) {
+			if (st < a[z.x].en) { // then z.x overlaps the query; write to the output array
+				if (n == m_b) KEXPAND(km, b, m_b);
+				b[n++] = z.x;
+			}
+			p = &stack[t++];
+			p->k = z.k - 1, p->x = z.x + (1LL<<(z.k-1)), p->w = 0; // push the right child
+		}
+	}
+	*b_ = b, *m_b_ = m_b;
+	return n;
+}
+
+/********************
+ * Global alignment *
+ ********************/
+
+int32_t mg_wfa_cmp(void *km, int32_t l1, const char *s1, int32_t l2, const char *s2, int32_t max_pen, int32_t *mlen, int32_t *blen)
+{
+	mwf_opt_t opt;
+	mwf_rst_t r;
+	int32_t i;
+	mwf_opt_init(&opt);
+	opt.max_s = max_pen;
+	opt.flag |= MWF_F_CIGAR;
+	mwf_wfa_exact(km, &opt, l1, s1, l2, s2, &r);
+	*mlen = *blen = 0;
+	for (i = 0; i < r.n_cigar; ++i) {
+		int32_t op = r.cigar[i]&0xf, len = r.cigar[i]>>4;
+		*blen += len;
+		if (op == 7) *mlen += len;
+	}
+	kfree(km, r.cigar);
+	return r.s < 0? -(l1 + l2) : (l1 + l2) / 2 - r.s;
+}

data/ext/minigraph/algo.h

@@ -0,0 +1,33 @@
+#ifndef MG_ALGO_H
+#define MG_ALGO_H
+
+#include <stdint.h>
+
+#define MG_MSS_TYPE int32_t
+#define MG_LIS_TYPE uint64_t
+
+typedef struct {
+    int32_t st, en;
+    MG_MSS_TYPE sc;
+} mg_msseg_t;
+
+typedef struct {
+	uint32_t st, en:31, rev:1;
+	int32_t far, i;
+} mg_intv_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+mg_msseg_t *mg_mss_all(void *km, int32_t n, const MG_MSS_TYPE *S, MG_MSS_TYPE min_sc, MG_MSS_TYPE xdrop, int32_t *n_seg);
+int32_t mg_intv_index(int32_t n, mg_intv_t *a);
+int32_t mg_intv_overlap(void *km, int32_t n_a, const mg_intv_t *a, int32_t st, int32_t en, int32_t **b_, int32_t *m_b_);
+void radix_sort_mg_intv(mg_intv_t *st, mg_intv_t *en);
+int32_t mg_wfa_cmp(void *km, int32_t l1, const char *s1, int32_t l2, const char *s2, int32_t max_pen, int32_t *mlen, int32_t *blen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/minigraph/asm-call.c

@@ -0,0 +1,147 @@
+#include <assert.h>
+#include "mgpriv.h"
+#include "ggen.h"
+#include "gfa-priv.h"
+#include "algo.h"
+
+int32_t mg_gc_index(void *km, int min_mapq, int min_map_len, int min_depth_len, const gfa_t *g, int32_t n_seq, mg_gchains_t *const* gcs,
+					double *a_dens, int32_t **soff_, int32_t **qoff_, mg_intv_t **sintv_, mg_intv_t **qintv_);
+
+typedef struct {
+	int32_t bid;
+	uint8_t is_stem:4, is_src:4;
+} callaux_t;
+
+typedef struct {
+	int32_t t, i;
+	int32_t st, en, strand;
+	int32_t qs, qe, glen;
+} bbaux_t;
+
+void mg_call_asm(const gfa_t *g, int32_t n_seq, const mg_bseq1_t *seq, mg_gchains_t *const *gcs, int32_t min_mapq, int32_t min_blen)
+{
+	int32_t i, j, t, max_acnt, *soff, *qoff, n_bb, m_ovlp = 0, *ovlp = 0;
+	mg_intv_t *sintv, *qintv;
+	double a_dens;
+	gfa_bubble_t *bb;
+	callaux_t *ca;
+	bbaux_t *ba;
+	kstring_t out = {0,0,0};
+
+	max_acnt = mg_gc_index(0, min_mapq, min_blen>>1, min_blen, g, n_seq, gcs, &a_dens, &soff, &qoff, &sintv, &qintv);
+	if (max_acnt == 0) return;
+
+	bb = gfa_bubble(g, &n_bb);
+	GFA_CALLOC(ba, n_bb);
+	GFA_CALLOC(ca, g->n_seg);
+	for (i = 0; i < n_bb; ++i) {
+		gfa_bubble_t *b = &bb[i];
+		assert(b->n_seg >= 2);
+		for (j = 0; j < b->n_seg; ++j)
+			ca[b->v[j]>>1].bid = i;
+		ca[b->v[0]>>1].is_stem = ca[b->v[b->n_seg-1]>>1].is_stem = 1;
+		ca[b->v[0]>>1].is_src = 1;
+		ba[i].t = -1;
+	}
+
+	for (t = 0; t < n_seq; ++t) {
+		const mg_gchains_t *gt = gcs[t];
+		for (i = 0; i < gt->n_gc; ++i) {
+			const mg_gchain_t *gc = &gt->gc[i];
+			int32_t st = -1;
+			for (j = 1; j < gc->cnt; ++j) {
+				const mg_llchain_t *lc = &gt->lc[gc->off + j];
+				if (!ca[lc->v>>1].is_stem && ca[(lc-1)->v>>1].is_stem) {
+					st = gc->off + j;
+				} else if ((ca[lc->v>>1].is_stem && !ca[(lc-1)->v>>1].is_stem && st > 0) || (ca[lc->v>>1].is_stem && ca[(lc-1)->v>>1].is_stem)) {
+					int32_t n_ovlp, k, en = gc->off + j, qs, qe, span, bid, strand, glen;
+					bbaux_t *p;
+
+					// determine the source and sink nodes
+					if (ca[lc->v>>1].is_stem && ca[(lc-1)->v>>1].is_stem) { // two adjacent stems: this is a deletion
+						st = gc->off + j;
+					} else {
+						assert(en > st);
+					}
+
+					// test overlap on the query
+					span = gt->a[gt->lc[st].off].y >> 32 & 0xff;
+					qs = (int32_t)gt->a[gt->lc[st - 1].off + gt->lc[st - 1].cnt - 1].y + 1; // NB: it is fine even if .cnt==0
+					qe = (int32_t)gt->a[gt->lc[en].off].y + 1 - span;
+					n_ovlp = mg_intv_overlap(0, qoff[t+1] - qoff[t], &qintv[qoff[t]], qs, qe, &ovlp, &m_ovlp);
+					if (n_ovlp > 1) continue; // overlap on the query - not orthologous
+
+					// test overlap on the graph
+					for (k = st, glen = 0; k < en; ++k) {
+						const mg_llchain_t *lk = &gt->lc[k];
+						int32_t seg = lk->v>>1;
+						n_ovlp = mg_intv_overlap(0, soff[seg+1] - soff[seg], &sintv[soff[seg]], 0, g->seg[seg].len, &ovlp, &m_ovlp);
+						glen += g->seg[seg].len;
+						if (n_ovlp > 1) break; // overlap on the graph - not orthoologous
+					}
+					if (k < en) continue;
+
+					// determine the bubble ID
+					assert(ca[gt->lc[st-1].v>>1].is_stem && ca[gt->lc[en].v>>1].is_stem);
+					if (ca[gt->lc[st-1].v>>1].bid < ca[gt->lc[en].v>>1].bid)
+						strand = 1;
+					else if (ca[gt->lc[st-1].v>>1].bid > ca[gt->lc[en].v>>1].bid)
+						strand = -1;
+					else {
+						if (ca[gt->lc[st-1].v>>1].is_src + ca[gt->lc[en].v>>1].is_src != 1) {
+							fprintf(stderr, "[W::%s] type-1 folded inversion alignment around %c%s <=> %s:%d-%d\n",
+									__func__, "><"[gt->lc[st].v&1], g->seg[gt->lc[st].v>>1].name, seq[t].name, qs, qe);
+							continue;
+						}
+						if (ca[gt->lc[st-1].v>>1].is_src) strand = 1;
+						else strand = -1;
+					}
+					bid = strand > 0? ca[gt->lc[st-1].v>>1].bid : ca[gt->lc[en].v>>1].bid;
+
+					// attach the bubble
+					for (k = st; k < en; ++k) // check consistency
+						if (ca[gt->lc[k].v>>1].bid != bid)
+							break;
+					if (k != en) { // this may happen around an inversion towards the end of an alignment chain
+						fprintf(stderr, "[W::%s] type-2 folded inversion alignment around %c%s <=> %s:%d-%d\n",
+								__func__, "><"[gt->lc[st].v&1], g->seg[gt->lc[st].v>>1].name, seq[t].name, qs, qe);
+						continue;
+					}
+					p = &ba[bid];
+					p->t = t, p->i = i, p->st = st, p->en = en, p->strand = strand, p->qs = qs, p->qe = qe, p->glen = glen;
+				}
+			}
+		}
+	}
+
+	for (i = 0; i < n_bb; ++i) {
+		gfa_bubble_t *b = &bb[i];
+		bbaux_t *a = &ba[i];
+		const mg_gchains_t *gt = gcs[a->t];
+		out.l = 0;
+		mg_sprintf_lite(&out, "%s\t%d\t%d\t%c%s\t%c%s\t", g->sseq[b->snid].name, b->ss, b->se, "><"[b->v[0]&1], g->seg[b->v[0]>>1].name,
+						"><"[b->v[b->n_seg-1]&1], g->seg[b->v[b->n_seg-1]>>1].name);
+		if (a->t >= 0) {
+			assert(a->strand != 0);
+			if (a->st == a->en) {
+				mg_sprintf_lite(&out, "*");
+			} else if (a->strand > 0) {
+				for (j = a->st; j < a->en; ++j)
+					mg_sprintf_lite(&out, "%c%s", "><"[gt->lc[j].v&1], g->seg[gt->lc[j].v>>1].name);
+			} else {
+				for (j = a->en - 1; j >= a->st; --j)
+					mg_sprintf_lite(&out, "%c%s", "<>"[gt->lc[j].v&1], g->seg[gt->lc[j].v>>1].name);
+			}
+			mg_sprintf_lite(&out, ":%d:%c:%s:%d:%d", a->glen, a->strand > 0? '+' : '-', seq[a->t].name, a->qs, a->qe);
+		} else {
+			mg_sprintf_lite(&out, ".");
+		}
+		puts(out.s);
+	}
+
+	free(ba); free(ca);
+	free(soff); free(qoff); free(sintv); free(qintv);
+	for (i = 0; i < n_bb; ++i) free(bb[i].v);
+	free(bb);
+	free(out.s);
+}