ruby-minigraph 0.0.20.0

data/ext/minigraph/gcmisc.c

@@ -0,0 +1,223 @@
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include "mgpriv.h"
+#include "kalloc.h"
+
+// reorder gcs->a[] and gcs->lc[] such that they are in the same order as gcs->gc[]
+void mg_gchain_restore_order(void *km, mg_gchains_t *gcs)
+{
+	int32_t i, n_a, n_lc;
+	mg_llchain_t *lc;
+	mg128_t *a;
+	KMALLOC(km, lc, gcs->n_lc);
+	KMALLOC(km, a, gcs->n_a);
+	for (i = 0, n_a = n_lc = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *gc = &gcs->gc[i];
+		assert(gc->cnt > 0);
+		memcpy(&lc[n_lc], &gcs->lc[gc->off], gc->cnt * sizeof(mg_llchain_t));
+		memcpy(&a[n_a], &gcs->a[gcs->lc[gc->off].off], gc->n_anchor * sizeof(mg128_t));
+		n_lc += gc->cnt, n_a += gc->n_anchor;
+	}
+	memcpy(gcs->lc, lc, gcs->n_lc * sizeof(mg_llchain_t));
+	memcpy(gcs->a, a, gcs->n_a * sizeof(mg128_t));
+	kfree(km, lc); kfree(km, a);
+	for (i = 0, n_lc = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *gc = &gcs->gc[i];
+		gc->off = n_lc;
+		n_lc += gc->cnt;
+	}
+	for (i = 0, n_a = 0; i < gcs->n_lc; ++i) {
+		mg_llchain_t *lc = &gcs->lc[i];
+		lc->off = n_a;
+		n_a += lc->cnt;
+	}
+}
+
+// recompute gcs->gc[].{off,n_anchor} and gcs->lc[].off, ASSUMING they are properly ordered (see mg_gchain_restore_order)
+void mg_gchain_restore_offset(mg_gchains_t *gcs)
+{
+	int32_t i, j, n_a, n_lc;
+	for (i = 0, n_a = n_lc = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *gc = &gcs->gc[i];
+		gc->off = n_lc;
+		for (j = 0, gc->n_anchor = 0; j < gc->cnt; ++j) {
+			mg_llchain_t *lc = &gcs->lc[n_lc + j];
+			lc->off = n_a;
+			n_a += lc->cnt;
+			gc->n_anchor += lc->cnt;
+		}
+		n_lc += gc->cnt;
+	}
+	assert(n_lc == gcs->n_lc && n_a == gcs->n_a);
+}
+
+// sort chains by score
+void mg_gchain_sort_by_score(void *km, mg_gchains_t *gcs)
+{
+	mg128_t *z;
+	mg_gchain_t *gc;
+	int32_t i;
+	KMALLOC(km, z, gcs->n_gc);
+	KMALLOC(km, gc, gcs->n_gc);
+	for (i = 0; i < gcs->n_gc; ++i)
+		z[i].x = (uint64_t)gcs->gc[i].score << 32 | gcs->gc[i].hash, z[i].y = i;
+	radix_sort_128x(z, z + gcs->n_gc);
+	for (i = gcs->n_gc - 1; i >= 0; --i)
+		gc[gcs->n_gc - 1 - i] = gcs->gc[z[i].y];
+	memcpy(gcs->gc, gc, gcs->n_gc * sizeof(mg_gchain_t));
+	kfree(km, z); kfree(km, gc);
+	mg_gchain_restore_order(km, gcs); // this put gcs in the proper order
+}
+
+// set r[].{id,parent,subsc}, ASSUMING r[] is sorted by score
+void mg_gchain_set_parent(void *km, float mask_level, int n, mg_gchain_t *r, int sub_diff, int hard_mask_level)
+{
+	int i, j, k, *w;
+	uint64_t *cov;
+	if (n <= 0) return;
+	for (i = 0; i < n; ++i) r[i].id = i;
+	cov = (uint64_t*)kmalloc(km, n * sizeof(uint64_t));
+	w = (int*)kmalloc(km, n * sizeof(int));
+	w[0] = 0, r[0].parent = 0;
+	for (i = 1, k = 1; i < n; ++i) {
+		mg_gchain_t *ri = &r[i];
+		int si = ri->qs, ei = ri->qe, n_cov = 0, uncov_len = 0;
+		if (hard_mask_level) goto skip_uncov;
+		for (j = 0; j < k; ++j) { // traverse existing primary hits to find overlapping hits
+			mg_gchain_t *rp = &r[w[j]];
+			int sj = rp->qs, ej = rp->qe;
+			if (ej <= si || sj >= ei) continue;
+			if (sj < si) sj = si;
+			if (ej > ei) ej = ei;
+			cov[n_cov++] = (uint64_t)sj<<32 | ej;
+		}
+		if (n_cov == 0) {
+			goto set_parent_test; // no overlapping primary hits; then i is a new primary hit
+		} else if (n_cov > 0) { // there are overlapping primary hits; find the length not covered by existing primary hits
+			int j, x = si;
+			radix_sort_gfa64(cov, cov + n_cov);
+			for (j = 0; j < n_cov; ++j) {
+				if ((int)(cov[j]>>32) > x) uncov_len += (cov[j]>>32) - x;
+				x = (int32_t)cov[j] > x? (int32_t)cov[j] : x;
+			}
+			if (ei > x) uncov_len += ei - x;
+		}
+skip_uncov:
+		for (j = 0; j < k; ++j) { // traverse existing primary hits again
+			mg_gchain_t *rp = &r[w[j]];
+			int sj = rp->qs, ej = rp->qe, min, max, ol;
+			if (ej <= si || sj >= ei) continue; // no overlap
+			min = ej - sj < ei - si? ej - sj : ei - si;
+			max = ej - sj > ei - si? ej - sj : ei - si;
+			ol = si < sj? (ei < sj? 0 : ei < ej? ei - sj : ej - sj) : (ej < si? 0 : ej < ei? ej - si : ei - si); // overlap length; TODO: this can be simplified
+			if ((float)ol / min - (float)uncov_len / max > mask_level) {
+				int cnt_sub = 0;
+				ri->parent = rp->parent;
+				rp->subsc = rp->subsc > ri->score? rp->subsc : ri->score;
+				if (ri->cnt >= rp->cnt) cnt_sub = 1;
+				if (cnt_sub) ++rp->n_sub;
+				break;
+			}
+		}
+set_parent_test:
+		if (j == k) w[k++] = i, ri->parent = i, ri->n_sub = 0;
+	}
+	kfree(km, cov);
+	kfree(km, w);
+}
+
+// set r[].flt, i.e. mark weak suboptimal chains as filtered
+int mg_gchain_flt_sub(float pri_ratio, int min_diff, int best_n, int n, mg_gchain_t *r)
+{
+	if (pri_ratio > 0.0f && n > 0) {
+		int i, k, n_2nd = 0;
+		for (i = k = 0; i < n; ++i) {
+			int p = r[i].parent;
+			if (p == i) { // primary
+				r[i].flt = 0, ++k;
+			} else if ((r[i].score >= r[p].score * pri_ratio || r[i].score + min_diff >= r[p].score) && n_2nd < best_n) {
+				if (!(r[i].qs == r[p].qs && r[i].qe == r[p].qe && r[i].ps == r[p].ps && r[i].pe == r[p].pe)) // not identical hits; TODO: check path as well
+					r[i].flt = 0, ++n_2nd, ++k;
+				else r[i].flt = 1;
+			} else r[i].flt = 1;
+		}
+		return k;
+	}
+	return n;
+}
+
+// hard drop filtered chains, ASSUMING gcs is properly ordered
+void mg_gchain_drop_flt(void *km, mg_gchains_t *gcs)
+{
+	int32_t i, n_gc, n_lc, n_a, n_lc0, n_a0, *o2n;
+	if (gcs->n_gc == 0) return;
+	KMALLOC(km, o2n, gcs->n_gc);
+	for (i = 0, n_gc = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *r = &gcs->gc[i];
+		o2n[i] = -1;
+		if (r->flt || r->cnt == 0) {
+			kfree(gcs->km, r->p);
+			continue;
+		}
+		o2n[i] = n_gc++;
+	}
+	n_gc = n_lc = n_a = 0;
+	n_lc0 = n_a0 = 0;
+	for (i = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *r = &gcs->gc[i];
+		if (o2n[i] >= 0) {
+			memmove(&gcs->a[n_a], &gcs->a[n_a0], r->n_anchor * sizeof(mg128_t));
+			memmove(&gcs->lc[n_lc], &gcs->lc[n_lc0], r->cnt * sizeof(mg_llchain_t));
+			gcs->gc[n_gc] = *r;
+			gcs->gc[n_gc].id = n_gc;
+			gcs->gc[n_gc].parent = o2n[gcs->gc[n_gc].parent];
+			++n_gc, n_lc += r->cnt, n_a += r->n_anchor;
+		}
+		n_lc0 += r->cnt, n_a0 += r->n_anchor;
+	}
+	assert(n_lc0 == gcs->n_lc && n_a0 == gcs->n_a);
+	kfree(km, o2n);
+	gcs->n_gc = n_gc, gcs->n_lc = n_lc, gcs->n_a = n_a;
+	if (n_a != n_a0) {
+		KREALLOC(gcs->km, gcs->a, gcs->n_a);
+		KREALLOC(gcs->km, gcs->lc, gcs->n_lc);
+		KREALLOC(gcs->km, gcs->gc, gcs->n_gc);
+	}
+	mg_gchain_restore_offset(gcs);
+}
+
+// estimate mapping quality
+void mg_gchain_set_mapq(void *km, mg_gchains_t *gcs, int qlen, int max_mini, int min_gc_score)
+{
+	static const float q_coef = 40.0f;
+	int64_t sum_sc = 0;
+	float uniq_ratio, r_sc, r_cnt;
+	int i, t_sc, t_cnt;
+	if (gcs == 0 || gcs->n_gc == 0) return;
+	t_sc = qlen < 100? qlen : 100;
+	t_cnt = max_mini < 10? max_mini : 10;
+	if (t_cnt < 5) t_cnt = 5;
+	r_sc = 1.0 / t_sc;
+	r_cnt = 1.0 / t_cnt;
+	for (i = 0; i < gcs->n_gc; ++i)
+		if (gcs->gc[i].parent == gcs->gc[i].id)
+			sum_sc += gcs->gc[i].score;
+	uniq_ratio = (float)sum_sc / (sum_sc + gcs->rep_len);
+	for (i = 0; i < gcs->n_gc; ++i) {
+		mg_gchain_t *r = &gcs->gc[i];
+		if (r->parent == r->id) {
+			int mapq, subsc;
+			float pen_s1 = (r->score > t_sc? 1.0f : r->score * r_sc) * uniq_ratio;
+			float x, pen_cm = r->n_anchor > t_cnt? 1.0f : r->n_anchor * r_cnt;
+			pen_cm = pen_s1 < pen_cm? pen_s1 : pen_cm;
+			subsc = r->subsc > min_gc_score? r->subsc : min_gc_score;
+			x = (float)subsc / r->score;
+			mapq = (int)(pen_cm * q_coef * (1.0f - x) * logf(r->score));
+			mapq -= (int)(4.343f * logf(r->n_sub + 1) + .499f);
+			mapq = mapq > 0? mapq : 0;
+			if (r->score > subsc && mapq == 0) mapq = 1;
+			r->mapq = mapq < 60? mapq : 60;
+		} else r->mapq = 0;
+	}
+}

data/ext/minigraph/gfa-aug.c

@@ -0,0 +1,260 @@
+#include <assert.h>
+#include <ctype.h>
+#include "gfa-priv.h"
+#include "ksort.h"
+
+typedef struct {
+	uint32_t side;
+	uint32_t ins:31, end:1;
+} gfa_split_t;
+
+#define split_key(p) ((p).side)
+KRADIX_SORT_INIT(split, gfa_split_t, split_key, 4)
+
+static inline void create_first_arc_semi(gfa_t *g, const gfa_seg_t *seg, uint32_t v, uint32_t w, int32_t rank, uint64_t link_id, int is_comp)
+{
+	gfa_arc_t *a;
+	if (g->n_arc == g->m_arc) GFA_EXPAND(g->arc, g->m_arc);
+	a = &g->arc[g->n_arc++];
+	a->v_lv = (uint64_t)v<<32 | seg[v>>1].len;
+	a->w = w;
+	a->rank = rank;
+	a->ov = a->ow = 0;
+	a->link_id = link_id;
+	a->del = 0;
+	a->comp = !!is_comp;
+}
+
+static inline void create_first_arc(gfa_t *g, const gfa_seg_t *seg, uint32_t v, uint32_t w, int32_t rank)
+{
+	uint64_t link_id = g->n_arc;
+	create_first_arc_semi(g, seg, v,   w,   rank, link_id, 0);
+	create_first_arc_semi(g, seg, w^1, v^1, rank, link_id, 1);
+}
+
+void gfa_augment(gfa_t *g, int32_t n_ins, const gfa_ins_t *ins, int32_t n_ctg, const char *const* name, const char *const* seq)
+{
+	int32_t i, j, k, *scnt, *soff, n_ctg_seg, n_old_seg, n_seg;
+	gfa_split_t *sp;
+	gfa_seg_t *seg;
+	char buf[16];
+	uint64_t t, n_old_arc = g->n_arc, *ins_side, *oldcnt;
+
+	if (n_ins <= 0 || n_ctg <= 0) return;
+
+	// set soff[]
+	GFA_CALLOC(scnt, g->n_seg);
+	for (i = 0; i < n_ins; ++i)
+		++scnt[ins[i].v[0]>>1], ++scnt[ins[i].v[1]>>1];
+	GFA_MALLOC(soff, g->n_seg + 1);
+	for (j = 1, soff[0] = 0; j <= g->n_seg; ++j)
+		soff[j] = soff[j-1] + scnt[j-1];
+
+	// populate sp[]
+	GFA_MALLOC(sp, soff[g->n_seg]);
+	GFA_BZERO(scnt, g->n_seg);
+	for (i = 0, n_ctg_seg = 0; i < n_ins; ++i) {
+		const gfa_ins_t *p = &ins[i];
+		for (k = 0; k < 2; ++k) {
+			uint32_t vlen = g->seg[p->v[k]>>1].len;
+			gfa_split_t *q = &sp[soff[p->v[k]>>1] + scnt[p->v[k]>>1]];
+			q->ins = i, q->end = k;
+			q->side = (p->v[k]&1? vlen - p->voff[k] : p->voff[k]) << 1 | ((p->v[k]&1) ^ k);
+			assert(q->side != (0<<1|0) && q->side != (vlen<<1|1)); // not possible to link such sides
+			++scnt[p->v[k]>>1];
+		}
+		if (p->coff[1] > p->coff[0])
+			++n_ctg_seg;
+	}
+	free(scnt);
+
+	// sort sp[]
+	for (j = 0, n_old_seg = 0; j < g->n_seg; ++j)
+		if (soff[j+1] - soff[j] > 1)
+			radix_sort_split(&sp[soff[j]], &sp[soff[j+1]]);
+
+	// precompute the number of segments after split
+	for (j = 0, n_old_seg = 0; j < g->n_seg; ++j) {
+		int32_t i0;
+		for (i0 = soff[j], i = i0 + 1, k = 0; i <= soff[j+1]; ++i)
+			if (i == soff[j+1] || sp[i0].side>>1 != sp[i].side>>1) {
+				if (sp[i0].side>>1 != 0 && sp[i0].side>>1 != g->seg[j].len) // otherwise no new segment will be created
+					++k;
+				i0 = i;
+			}
+		n_old_seg += k + 1;
+	}
+
+	// compute ins_side[] and split old segments
+	n_seg = n_old_seg + n_ctg_seg;
+	GFA_CALLOC(seg, n_seg);
+	GFA_CALLOC(ins_side, n_ins);
+	GFA_MALLOC(oldcnt, g->n_seg);
+	for (j = 0, k = 0; j < g->n_seg; ++j) {
+		int32_t i0, l, off = 0, k0 = k;
+		gfa_seg_t *s = &g->seg[j];
+		gfa_seg_t *t = &seg[k]; // this is so far a placeholder
+		// create the first half of a new segment
+		snprintf(buf, 15, "s%d", k + 1);
+		t->name = gfa_strdup(buf);
+		t->snid = s->snid, t->soff = s->soff, t->rank = s->rank;
+		// iterate over splits
+		for (i0 = soff[j], i = i0 + 1; i <= soff[j+1]; ++i) {
+			if (i == soff[j+1] || sp[i].side>>1 != sp[i0].side>>1) {
+				gfa_split_t *q0 = &sp[i0];
+				for (l = i0; l < i; ++l) {
+					gfa_split_t *q = &sp[l];
+					int32_t shift = q->end == 0? 32 : 0; // first end on the higher 32 bits
+					int32_t side = q->side & 1;
+					int32_t which = q->side>>1 == 0? 0 : side; // special-casing when q->side==1, because no new segment created in this case
+					ins_side[q->ins] |= (uint64_t)((uint32_t)(k + which) << 1 | (side^q->end)) << shift;
+				}
+				if (q0->side>>1 != 0 && q0->side>>1 != g->seg[j].len) { // create a new segment
+					t->len = (q0->side>>1) - off;
+					GFA_MALLOC(t->seq, t->len + 1);
+					memcpy(t->seq, &s->seq[off], t->len);
+					t->seq[t->len] = 0;
+					off += t->len;
+					t = &seg[++k]; // create a new segment
+					snprintf(buf, 15, "s%d", k + 1);
+					t->name = gfa_strdup(buf);
+					t->snid = s->snid, t->soff = s->soff + off, t->rank = s->rank;
+				}
+				i0 = i;
+			}
+		}
+		// finish the last segment
+		t->len = s->len - off;
+		GFA_MALLOC(t->seq, t->len + 1);
+		memcpy(t->seq, &s->seq[off], t->len);
+		t->seq[t->len] = 0;
+		++k;
+		oldcnt[j] = (uint64_t)k0 << 32 | (k - k0);
+		// add new arcs between newly created segments
+		for (i = 0; i < k - k0 - 1; ++i)
+			create_first_arc(g, seg, (uint32_t)(k0+i)<<1, (uint32_t)(k0+i+1)<<1, s->rank);
+	}
+	assert(k == n_old_seg);
+	free(soff);
+	free(sp);
+
+	// update existing g->arc[]
+	for (t = 0; t < n_old_arc; ++t) {
+		gfa_arc_t *a = &g->arc[t];
+		uint32_t v = a->v_lv >> 32;
+		uint32_t off = oldcnt[v>>1]>>32, cnt = (uint32_t)oldcnt[v>>1];
+		v = (v&1) == 0? (off+cnt-1)<<1 : off<<1 | 1;
+		a->v_lv = (uint64_t)v << 32 | seg[v>>1].len;
+		off = oldcnt[a->w>>1]>>32, cnt = (uint32_t)oldcnt[a->w>>1];
+		a->w = (a->w&1) == 0? off<<1 : (off+cnt-1)<<1 | 1;
+	}
+	free(oldcnt);
+
+	// create newly inserted segments
+	for (i = 0, k = n_old_seg; i < n_ins; ++i) {
+		const gfa_ins_t *p = &ins[i];
+		if (p->coff[0] < p->coff[1]) { // not a pure deletion
+			gfa_seg_t *t = &seg[k];
+			snprintf(buf, 15, "s%d", k + 1);
+			t->name = gfa_strdup(buf);
+			GFA_MALLOC(t->seq, p->coff[1] - p->coff[0] + 1);
+			for (j = 0; j < p->coff[1] - p->coff[0]; ++j)
+				t->seq[j] = seq[p->ctg][p->coff[0] + j];
+			t->seq[j] = 0;
+			t->len = j;
+			t->snid = gfa_sseq_add(g, name[p->ctg]);
+			t->soff = p->coff[0];
+			t->rank = g->max_rank + 1; // TODO: to deal with SN/SO/SR tags somewhere
+			gfa_sseq_update(g, t);
+			create_first_arc(g, seg, ins_side[i]>>32, (uint32_t)k<<1, t->rank);
+			create_first_arc(g, seg, (uint32_t)k<<1, (uint32_t)ins_side[i], t->rank);
+			++k;
+		} else { // a pure deletion
+			create_first_arc(g, seg, ins_side[i]>>32, (uint32_t)ins_side[i], g->max_rank + 1);
+		}
+	}
+	free(ins_side);
+
+	// update *g
+	for (j = 0; j < g->n_seg; ++j) {
+		free(g->seg[j].name);
+		free(g->seg[j].seq);
+		free(g->seg[j].aux.aux);
+	}
+	free(g->seg);
+	g->seg = seg, g->n_seg = g->m_seg = n_seg;
+	++g->max_rank;
+	GFA_REALLOC(g->link_aux, g->m_arc);
+	GFA_BZERO(&g->link_aux[n_old_arc], g->m_arc - n_old_arc);
+	gfa_arc_sort(g);
+	gfa_arc_index(g);
+	gfa_fix_multi(g);
+	// k = gfa_fix_symm(g); assert(k == 0); // for debugging; the graph should be symmetric
+}
+
+static int32_t gfa_ins_shrink_semi(const gfa_t *g, int32_t pen, uint32_t v, int32_t voff, int32_t coff, uint32_t vv, int32_t vend, int32_t cend, const char *seq)
+{
+	int32_t i, j, l, dir, score, max, max_l;
+	if (cend == coff) return 0;
+	dir = cend > coff? +1 : -1;
+	for (i = coff, j = voff, l = max_l = 0, score = max = 0; i != cend; i += dir, j += dir) {
+		int32_t cg, vlen = g->seg[v>>1].len;
+		if (j == vlen || j == -1) break;
+		if (vv == v && j == vend) break;
+		++l;
+		cg = (v&1) == 0? g->seg[v>>1].seq[j] : gfa_comp_table[(uint8_t)g->seg[v>>1].seq[vlen - 1 - j]];
+		score += tolower(cg) == tolower(seq[i])? +1 : -pen;
+		if (score > max) max = score, max_l = l;
+		if (score < max - pen * pen) break; // X-drop
+	}
+	return max_l;
+}
+
+int gfa_ins_adj(const gfa_t *g, int pen, gfa_ins_t *ins, const char *seq) // min_len is NOT used for now
+{
+	int32_t l, tot = 0;
+	l = gfa_ins_shrink_semi(g, pen, ins->v[0], ins->voff[0], ins->coff[0], ins->v[1], ins->voff[1], ins->coff[1], seq);
+	ins->voff[0] += l, ins->coff[0] += l, tot += l;
+	l = gfa_ins_shrink_semi(g, pen, ins->v[1], ins->voff[1] - 1, ins->coff[1] - 1, ins->v[0], ins->voff[0] - 1, ins->coff[0] - 1, seq);
+	ins->voff[1] -= l, ins->coff[1] -= l, tot += l;
+	return tot;
+}
+
+static inline int check_multi(const gfa_t *g, const gfa_ins_t *ins)
+{
+	if (ins->v[0] != ins->v[1] && ins->coff[1] - ins->coff[0] == 0) {
+		const gfa_seg_t *s[2];
+		uint32_t v[2];
+		s[0] = &g->seg[ins->v[0]>>1];
+		s[1] = &g->seg[ins->v[1]>>1];
+		if (ins->voff[0] != 0 && ins->voff[0] != s[0]->len) return 0;
+		if (ins->voff[1] != 0 && ins->voff[1] != s[1]->len) return 0;
+		v[0] = ins->voff[0] == 0? ins->v[0]^1 : ins->v[0];
+		v[1] = ins->voff[1] == 0? ins->v[1] : ins->v[1]^1;
+		if (gfa_find_arc(g, v[0], v[1]) >= 0) return 1;
+		return 0;
+	} else return 0;
+}
+
+int32_t gfa_ins_filter(const gfa_t *g, int32_t n_ins, gfa_ins_t *ins) // filter out impossible inserts
+{
+	int32_t i, k, n;
+	for (i = 0, n = 0; i < n_ins; ++i) {
+		gfa_ins_t *p = &ins[i];
+		for (k = 0; k < 2; ++k) {
+			uint32_t vlen = g->seg[p->v[k]>>1].len;
+			uint32_t side = (p->v[k]&1? vlen - p->voff[k] : p->voff[k]) << 1 | ((p->v[k]&1) ^ k);
+			if (side == (0<<1|0) || side == (vlen<<1|1))
+				break;
+		}
+		if (k != 2 || check_multi(g, p)) { // multi-link may happen due to inconsistency between graph chaining and WFA alignment 
+			if (gfa_verbose >= 2)
+				fprintf(stderr, "[W::%s] %s between %c%s and %c%s derived from the %d-th query at %d-%d\n",
+						__func__, k != 2? "impossible insert" : "multi-link",
+						"><"[p->v[0]&1], g->seg[p->v[0]>>1].name, "><"[p->v[1]&1], g->seg[p->v[1]>>1].name, p->ctg, p->coff[0], p->coff[1]);
+			continue;
+		}
+		ins[n++] = ins[i];
+	}
+	return n;
+}