bio-cgranges 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 618c6866b3f708b148682a529b73efda7b782bfc567f92949f72c237fd98435b
+  data.tar.gz: 0ebbc69b7858f934fd98f60500e49b7300774b21e05ee04c654d55746e18f00b
+SHA512:
+  metadata.gz: 0444fad48ec7b6266072f2b7fb23684bf295703121c6d0b5b392e3c150de6dda02adbd1ecff161793b5f1a821f8d10cac564c4c60042f5fc4cc191bb26181620
+  data.tar.gz: 7f783598ec7ed7937c8163593901f055463175e4b16ab0073cf41bb96341f858077877524c5e1409369822e1efd5eaed80a11acc6c7678d9e27dee4ee3e14dec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 kojix2
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# bio-cgranges
+
+[![Gem Version](https://badge.fury.io/rb/bio-cgranges.svg)](https://badge.fury.io/rb/bio-cgranges)
+[![test](https://github.com/ruby-on-bioc/bio-cgranges/actions/workflows/ci.yml/badge.svg)](https://github.com/ruby-on-bioc/bio-cgranges/actions/workflows/ci.yml)
+[![dics](https://img.shields.io/badge/docs-stable-blue.svg)](https://rubydoc.info/gems/bio-cgranges)
+
+Ruby bindings to [lh3/cgranges](https://github.com/lh3/cgranges).
+
+> cgranges is a small C library for genomic interval overlap queries
+
+## Installation
+
+```sh
+gem install bio-cgranges
+```
+
+## Usage
+
+```ruby
+require "bio/cgranges"
+
+granges = Bio::CGRanges.new
+granges.add("chr1", 10, 20, 0)
+       .add("chr1", 15, 25, 1)
+       .add("chr1", 30, 40, 2)
+       .add("chr1", 10, 25, 3)
+       .add("chr1", 15, 20, 4)
+       .add("chr2", 10, 20, 5)
+       .index
+       
+granges.overlap("chr1", 12, 22)
+# [["chr1", 10, 20, 0],
+#  ["chr1", 10, 25, 3],
+#  ["chr1", 15, 25, 1],
+#  ["chr1", 15, 20, 4]]
+
+granges.contain("chr1", 12, 22)
+# [["chr1", 15, 20, 4]]
+```
+
+```
+0.........5.........10........15........20........25........30........35........40
+|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
+                     0-0-0-0-0-0-0-0-0-0
+                               1-1-1-1-1-1-1-1-1-1
+                                                             2-2-2-2-2-2-2-2-2-2
+                     3-3-3-3-3-3-3-3-3-3-3-3-3-3-3
+                               4-4-4-4-4
+           5-5-5-5-5
+                         Q-Q-Q-Q-Q-Q-Q-Q-Q-Q
+|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|
+0.........5.........10........15........20........25........30........35........40
+```
+
+## Development
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby-on-bioc/bio-cgranges.
+
+    Do you need commit rights to my repository?
+    Do you want to get admin rights and take over the project?
+    If so, please feel free to contact us @kojix2.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+require "rake/extensiontask"
+
+task build: :compile
+
+Rake::ExtensionTask.new("cgranges") do |ext|
+  ext.lib_dir = "lib/bio/cgranges"
+  ext.ext_dir = "ext/bio/cgranges"
+end
+
+desc "Remove object file"
+task :remove_object_file do
+  Dir["ext/**/*.{o,bundle}"].each do |f|
+    FileUtils.rm(f)
+  end
+end
+
+task default: %i[
+  clobber
+  compile
+  remove_object_file
+  test
+  rubocop
+]
+
+task cleanall: %i[
+  clobber
+  remove_object_file
+  clean
+]

data/ext/bio/cgranges/cgranges/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2019     Dana-Farber Cancer Institute
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/ext/bio/cgranges/cgranges/README.md

@@ -0,0 +1,133 @@
+## Introduction
+
+cgranges is a small C library for genomic interval overlap queries: given a
+genomic region *r* and a set of regions *R*, finding all regions in *R* that
+overlaps *r*. Although this library is based on [interval tree][itree], a well
+known data structure, the core algorithm of cgranges is distinct from all
+existing implementations to the best of our knowledge.  Specifically, the
+interval tree in cgranges is implicitly encoded as a plain sorted array
+(similar to [binary heap][bheap] but packed differently). Tree
+traversal is achieved by jumping between array indices. This treatment makes
+cgranges very efficient and compact in memory. The core algorithm can be
+implemented in ~50 lines of C++ code, much shorter than others as well. Please
+see the code comments in [cpp/IITree.h](cpp/IITree.h) for details.
+
+## Usage
+
+### Test with BED coverage
+
+For testing purposes, this repo implements the [bedtools coverage][bedcov] tool
+with cgranges. The source code is located in the [test/](test) directory. You
+can compile and run the test with:
+```sh
+cd test && make
+./bedcov-cr test1.bed test2.bed
+```
+The first BED file is loaded into RAM and indexed. The depth and the breadth of
+coverage of each region in the second file is computed by query against the
+index of the first file.
+
+The [test/](test) directory also contains a few other implementations based on
+[IntervalTree.h][ekg-itree] in C++, [quicksect][quicksect] in Cython and
+[ncls][ncls] in Cython. The table below shows timing and peak memory on two
+test BEDs available in the release page. The first BED contains GenCode
+annotations with ~1.2 million lines, mixing all types of features. The second
+contains ~10 million direct-RNA mappings. Time1a/Mem1a indexes the GenCode BED
+into memory. Time1b adds whole chromosome intervals to the GenCode BED when
+indexing. Time2/Mem2 indexes the RNA-mapping BED into memory. Numbers are
+averaged over 5 runs.
+
+|Algo.   |Lang. |Cov|Program         |Time1a|Time1b|Mem1a   |Time2 |Mem2    |
+|:-------|:-----|:-:|:---------------|-----:|-----:|-------:|-----:|-------:|
+|IAITree |C     |Y  |cgranges        |9.0s  |13.9s |19.1MB  |4.6s  |138.4MB |
+|IAITree |C++   |Y  |cpp/iitree.h    |11.1s |24.5s |22.4MB  |5.8s  |160.4MB |
+|CITree  |C++   |Y  |IntervalTree.h  |17.4s |17.4s |27.2MB  |10.5s |179.5MB |
+|IAITree |C     |N  |cgranges        |7.6s  |13.0s |19.1MB  |4.1s  |138.4MB |
+|AIList  |C     |N  |3rd-party/AIList|7.9s  |8.1s  |14.4MB  |6.5s  |104.8MB |
+|NCList  |C     |N  |3rd-party/NCList|13.0s |13.4s |21.4MB  |10.6s |183.0MB |
+|AITree  |C     |N  |3rd-party/AITree|16.8s |18.4s |73.4MB  |27.3s |546.4MB |
+|IAITree |Cython|N  |cgranges        |56.6s |63.9s |23.4MB  |43.9s |143.1MB |
+|binning |C++   |Y  |bedtools        |201.9s|280.4s|478.5MB |149.1s|3438.1MB|
+
+Here, IAITree = implicit augmented interval tree, used by cgranges;
+CITree = centered interval tree, used by [Erik Garrison's
+IntervalTree][itree]; AIList = augmented interval list, by [Feng et
+al][ailist]; NCList = nested containment list, taken from [ncls][ncls] by Feng
+et al; AITree = augmented interval tree, from [kerneltree][kerneltree].
+"Cov" indicates whether the program calculates breadth of coverage.
+Comments:
+
+* AIList keeps start and end only. IAITree and CITree addtionally store a
+  4-byte "ID" field per interval to reference the source of interval. This is
+  partly why AIList uses the least memory.
+
+* IAITree is more sensitive to the worse case: the presence of an interval
+  spanning the whole chromosome.
+
+* IAITree uses an efficient radix sort. CITree uses std::sort from STL, which
+  is ok. AIList and NCList use qsort from libc, which is slow. Faster sorting
+  leads to faster indexing.
+
+* IAITree in C++ uses identical core algorithm to the C version, but limited by
+  its APIs, it wastes time on memory locality and management. CITree has a
+  similar issue.
+
+* Computing coverage is better done when the returned list of intervals are
+  start sorted. IAITree returns sorted list. CITree doesn't. Not sure about
+  others. Computing coverage takes a couple of seconds. Sorting will be slower.
+
+* Printing intervals also takes a noticeable fraction of time. Custom printf
+  equivalent would be faster.
+
+* IAITree+Cython is a wrapper around the C version of cgranges. Cython adds
+  significant overhead.
+
+* Bedtools is designed for a variety of applications in addition to computing
+  coverage. It may keep other information in its internal data structure. This
+  micro-benchmark may be unfair to bedtools.
+
+* In general, the performance is affected a lot by subtle implementation
+  details. CITree, IAITree, NCList and AIList are all broadly comparable in
+  performance. AITree is not recommended when indexed intervals are immutable.
+
+### Use cgranges as a C library
+
+```c
+cgranges_t *cr = cr_init(); // initialize a cgranges_t object
+cr_add(cr, "chr1", 20, 30, 0); // add a genomic interval
+cr_add(cr, "chr2", 10, 30, 1);
+cr_add(cr, "chr1", 10, 25, 2);
+cr_index(cr); // index
+
+int64_t i, n, *b = 0, max_b = 0;
+n = cr_overlap(cr, "chr1", 15, 22, &b, &max_b); // overlap query; output array b[] can be reused
+for (i = 0; i < n; ++i) // traverse overlapping intervals
+	printf("%d\t%d\t%d\n", cr_start(cr, b[i]), cr_end(cr, b[i]), cr_label(cr, b[i]));
+free(b); // b[] is allocated by malloc() inside cr_overlap(), so needs to be freed with free()
+
+cr_destroy(cr);
+```
+
+### Use IITree as a C++ library
+
+```cpp
+IITree<int, int> tree;
+tree.add(12, 34, 0); // add an interval
+tree.add(0, 23, 1);
+tree.add(34, 56, 2);
+tree.index(); // index
+std::vector<size_t> a;
+tree.overlap(22, 25, a); // retrieve overlaps
+for (size_t i = 0; i < a.size(); ++i)
+	printf("%d\t%d\t%d\n", tree.start(a[i]), tree.end(a[i]), tree.data(a[i]));
+```
+
+[bedcov]: https://bedtools.readthedocs.io/en/latest/content/tools/coverage.html
+[ekg-itree]: https://github.com/ekg/intervaltree
+[quicksect]: https://github.com/brentp/quicksect
+[ncls]: https://github.com/hunt-genes/ncls
+[citree]: https://en.wikipedia.org/wiki/Interval_tree#Centered_interval_tree
+[itree]: https://en.wikipedia.org/wiki/Interval_tree
+[bheap]: https://en.wikipedia.org/wiki/Binary_heap
+[ailist]: https://www.biorxiv.org/content/10.1101/593657v1
+[kerneltree]: https://github.com/biocore-ntnu/kerneltree

data/ext/bio/cgranges/cgranges/cgranges.c

@@ -0,0 +1,330 @@
+#include <stdio.h>
+#include <assert.h>
+#include "cgranges.h"
+#include "khash.h"
+
+/**************
+ * Radix sort *
+ **************/
+
+#define RS_MIN_SIZE 64
+#define RS_MAX_BITS 8
+
+#define KRADIX_SORT_INIT(name, rstype_t, rskey, sizeof_key) \
+	typedef struct { \
+		rstype_t *b, *e; \
+	} rsbucket_##name##_t; \
+	void rs_insertsort_##name(rstype_t *beg, rstype_t *end) \
+	{ \
+		rstype_t *i; \
+		for (i = beg + 1; i < end; ++i) \
+			if (rskey(*i) < rskey(*(i - 1))) { \
+				rstype_t *j, tmp = *i; \
+				for (j = i; j > beg && rskey(tmp) < rskey(*(j-1)); --j) \
+					*j = *(j - 1); \
+				*j = tmp; \
+			} \
+	} \
+	void rs_sort_##name(rstype_t *beg, rstype_t *end, int n_bits, int s) \
+	{ \
+		rstype_t *i; \
+		int size = 1<<n_bits, m = size - 1; \
+		rsbucket_##name##_t *k, b[1<<RS_MAX_BITS], *be = b + size; \
+		assert(n_bits <= RS_MAX_BITS); \
+		for (k = b; k != be; ++k) k->b = k->e = beg; \
+		for (i = beg; i != end; ++i) ++b[rskey(*i)>>s&m].e; \
+		for (k = b + 1; k != be; ++k) \
+			k->e += (k-1)->e - beg, k->b = (k-1)->e; \
+		for (k = b; k != be;) { \
+			if (k->b != k->e) { \
+				rsbucket_##name##_t *l; \
+				if ((l = b + (rskey(*k->b)>>s&m)) != k) { \
+					rstype_t tmp = *k->b, swap; \
+					do { \
+						swap = tmp; tmp = *l->b; *l->b++ = swap; \
+						l = b + (rskey(tmp)>>s&m); \
+					} while (l != k); \
+					*k->b++ = tmp; \
+				} else ++k->b; \
+			} else ++k; \
+		} \
+		for (b->b = beg, k = b + 1; k != be; ++k) k->b = (k-1)->e; \
+		if (s) { \
+			s = s > n_bits? s - n_bits : 0; \
+			for (k = b; k != be; ++k) \
+				if (k->e - k->b > RS_MIN_SIZE) rs_sort_##name(k->b, k->e, n_bits, s); \
+				else if (k->e - k->b > 1) rs_insertsort_##name(k->b, k->e); \
+		} \
+	} \
+	void radix_sort_##name(rstype_t *beg, rstype_t *end) \
+	{ \
+		if (end - beg <= RS_MIN_SIZE) rs_insertsort_##name(beg, end); \
+		else rs_sort_##name(beg, end, RS_MAX_BITS, (sizeof_key - 1) * RS_MAX_BITS); \
+	}
+
+/*********************
+ * Convenient macros *
+ *********************/
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#define CALLOC(type, len) ((type*)calloc((len), sizeof(type)))
+#define REALLOC(ptr, len) ((ptr) = (__typeof__(ptr))realloc((ptr), (len) * sizeof(*(ptr))))
+
+#define EXPAND(a, m) do { \
+		(m) = (m)? (m) + ((m)>>1) : 16; \
+		REALLOC((a), (m)); \
+	} while (0)
+
+/********************
+ * Basic operations *
+ ********************/
+
+#define cr_intv_key(r) ((r).x)
+KRADIX_SORT_INIT(cr_intv, cr_intv_t, cr_intv_key, 8)
+
+KHASH_MAP_INIT_STR(str, int32_t)
+typedef khash_t(str) strhash_t;
+
+cgranges_t *cr_init(void)
+{
+	cgranges_t *cr;
+	cr = CALLOC(cgranges_t, 1);
+	cr->hc = kh_init(str);
+	return cr;
+}
+
+void cr_destroy(cgranges_t *cr)
+{
+	int32_t i;
+	if (cr == 0) return;
+	for (i = 0; i < cr->n_ctg; ++i)
+		free(cr->ctg[i].name);
+	free(cr->ctg);
+	kh_destroy(str, (strhash_t*)cr->hc);
+	free(cr);
+}
+
+int32_t cr_add_ctg(cgranges_t *cr, const char *ctg, int32_t len)
+{
+	int absent;
+	khint_t k;
+	strhash_t *h = (strhash_t*)cr->hc;
+	k = kh_put(str, h, ctg, &absent);
+	if (absent) {
+		cr_ctg_t *p;
+		if (cr->n_ctg == cr->m_ctg)
+			EXPAND(cr->ctg, cr->m_ctg);
+		kh_val(h, k) = cr->n_ctg;
+		p = &cr->ctg[cr->n_ctg++];
+		p->name = strdup(ctg);
+		kh_key(h, k) = p->name;
+		p->len = len;
+		p->n = 0, p->off = -1;
+	}
+	if (len > cr->ctg[kh_val(h, k)].len)
+		cr->ctg[kh_val(h, k)].len = len;
+	return kh_val(h, k);
+}
+
+int32_t cr_get_ctg(const cgranges_t *cr, const char *ctg)
+{
+	khint_t k;
+	strhash_t *h = (strhash_t*)cr->hc;
+	k = kh_get(str, h, ctg);
+	return k == kh_end(h)? -1 : kh_val(h, k);
+}
+
+cr_intv_t *cr_add(cgranges_t *cr, const char *ctg, int32_t st, int32_t en, int32_t label_int)
+{
+	cr_intv_t *p;
+	int32_t k;
+	if (st > en) return 0;
+	k = cr_add_ctg(cr, ctg, 0);
+	if (cr->n_r == cr->m_r)
+		EXPAND(cr->r, cr->m_r);
+	p = &cr->r[cr->n_r++];
+	p->x = (uint64_t)k << 32 | st;
+	p->y = en;
+	p->label = label_int;
+	if (cr->ctg[k].len < en)
+		cr->ctg[k].len = en;
+	return p;
+}
+
+void cr_sort(cgranges_t *cr)
+{
+	if (cr->n_ctg == 0 || cr->n_r == 0) return;
+	radix_sort_cr_intv(cr->r, cr->r + cr->n_r);
+}
+
+int32_t cr_is_sorted(const cgranges_t *cr)
+{
+	uint64_t i;
+	for (i = 1; i < cr->n_r; ++i)
+		if (cr->r[i-1].x > cr->r[i].x)
+			break;
+	return (i == cr->n_r);
+}
+
+/************
+ * Indexing *
+ ************/
+
+void cr_index_prepare(cgranges_t *cr)
+{
+	int64_t i, st;
+	if (!cr_is_sorted(cr)) cr_sort(cr);
+	for (st = 0, i = 1; i <= cr->n_r; ++i) {
+		if (i == cr->n_r || cr->r[i].x>>32 != cr->r[st].x>>32) {
+			int32_t ctg = cr->r[st].x>>32;
+			cr->ctg[ctg].off = st;
+			cr->ctg[ctg].n = i - st;
+			st = i;
+		}
+	}
+	for (i = 0; i < cr->n_r; ++i) {
+		cr_intv_t *r = &cr->r[i];
+		r->x = r->x<<32 | r->y;
+		r->y = 0;
+	}
+}
+
+int32_t cr_index1(cr_intv_t *a, int64_t n)
+{
+	int64_t i, last_i;
+	int32_t last, k;
+	if (n <= 0) return -1;
+	for (i = 0; i < n; i += 2) last_i = i, last = a[i].y = (int32_t)a[i].x;
+	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].y;
+			int32_t er = i + x < n? a[i + x].y : last;
+			int32_t e = (int32_t)a[i].x;
+			e = e > el? e : el;
+			e = e > er? e : er;
+			a[i].y = e;
+		}
+		last_i = last_i>>k&1? last_i - x : last_i + x;
+		if (last_i < n && a[last_i].y > last)
+			last = a[last_i].y;
+	}
+	return k - 1;
+}
+
+void cr_index(cgranges_t *cr)
+{
+	int32_t i;
+	cr_index_prepare(cr);
+	for (i = 0; i < cr->n_ctg; ++i)
+		cr->ctg[i].root_k = cr_index1(&cr->r[cr->ctg[i].off], cr->ctg[i].n);
+}
+
+/*********
+ * Query *
+ *********/
+
+int64_t cr_min_start_int(const cgranges_t *cr, int32_t ctg_id, int32_t st) // find the smallest i such that cr_st(&r[i]) >= st
+{
+	int64_t left, right;
+	const cr_ctg_t *c;
+	const cr_intv_t *r;
+
+	if (ctg_id < 0 || ctg_id >= cr->n_ctg) return -1;
+	c = &cr->ctg[ctg_id];
+	r = &cr->r[c->off];
+	if (c->n == 0) return -1;
+	left = 0, right = c->n;
+	while (right > left) {
+		int64_t mid = left + ((right - left) >> 1);
+		if (cr_st(&r[mid]) >= st) right = mid;
+		else left = mid + 1;
+	}
+	assert(left == right);
+	return left == c->n? -1 : c->off + left;
+}
+
+typedef struct {
+	int64_t x;
+	int32_t k, w;
+} istack_t;
+
+int64_t cr_overlap_int(const cgranges_t *cr, int32_t ctg_id, int32_t st, int32_t en, int64_t **b_, int64_t *m_b_)
+{
+	int32_t t = 0;
+	const cr_ctg_t *c;
+	const cr_intv_t *r;
+	int64_t *b = *b_, m_b = *m_b_, n = 0;
+	istack_t stack[64], *p;
+
+	if (ctg_id < 0 || ctg_id >= cr->n_ctg) return 0;
+	c = &cr->ctg[ctg_id];
+	r = &cr->r[c->off];
+	p = &stack[t++];
+	p->k = c->root_k, 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
+			int64_t i, i0 = z.x >> z.k << z.k, i1 = i0 + (1LL<<(z.k+1)) - 1;
+			if (i1 >= c->n) i1 = c->n;
+			for (i = i0; i < i1 && cr_st(&r[i]) < en; ++i)
+				if (st < cr_en(&r[i])) {
+					if (n == m_b) EXPAND(b, m_b);
+					b[n++] = c->off + i;
+				}
+		} else if (z.w == 0) { // if left child not processed
+			int64_t y = z.x - (1LL<<(z.k-1));
+			p = &stack[t++];
+			p->k = z.k, p->x = z.x, p->w = 1;
+			if (y >= c->n || r[y].y > 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 < c->n && cr_st(&r[z.x]) < en) {
+			if (st < cr_en(&r[z.x])) { // then z.x overlaps the query; write to the output array
+				if (n == m_b) EXPAND(b, m_b);
+				b[n++] = c->off + 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;
+}
+
+int64_t cr_contain_int(const cgranges_t *cr, int32_t ctg_id, int32_t st, int32_t en, int64_t **b_, int64_t *m_b_)
+{
+	int64_t n = 0, i, s, e, *b = *b_, m_b = *m_b_;
+	s = cr_min_start_int(cr, ctg_id, st);
+	if (s < 0) return 0;
+	e = cr->ctg[ctg_id].off + cr->ctg[ctg_id].n;
+	for (i = s; i < e; ++i) {
+		const cr_intv_t *r = &cr->r[i];
+		if (cr_st(r) >= en) break;
+		if (cr_st(r) >= st && cr_en(r) <= en) {
+			if (n == m_b) EXPAND(b, m_b);
+			b[n++] = i;
+		}
+	}
+	*b_ = b, *m_b_ = m_b;
+	return n;
+}
+
+int64_t cr_min_start(const cgranges_t *cr, const char *ctg, int32_t st)
+{
+	return cr_min_start_int(cr, cr_get_ctg(cr, ctg), st);
+}
+
+int64_t cr_overlap(const cgranges_t *cr, const char *ctg, int32_t st, int32_t en, int64_t **b_, int64_t *m_b_)
+{
+	return cr_overlap_int(cr, cr_get_ctg(cr, ctg), st, en, b_, m_b_);
+}
+
+int64_t cr_contain(const cgranges_t *cr, const char *ctg, int32_t st, int32_t en, int64_t **b_, int64_t *m_b_)
+{
+	return cr_contain_int(cr, cr_get_ctg(cr, ctg), st, en, b_, m_b_);
+}