ngs_server 0.4 → 0.5

data/ext/tabix/NEWS

@@ -0,0 +1,126 @@
+Release 0.2.4 (10 April, 2011)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Give an error if the index file is older than the data file.
+
+ * Avoid a segfault given flawed input.
+
+ * Added Python APIs contributed by Hyeshik Chang. The new APIs do not bind to
+   the dynamic library and are reported to be faster. Pysam also comes with a
+   tabix binding.
+
+ * Added option "-r" for efficient header replacement.
+
+ * Added BED support.
+
+ * Synchronized the BGZF library between tabix and samtools.
+
+(0.2.4: 10 April 2011, r949)
+
+
+
+Beta Release 0.2.3 (8 December, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Fixed a minor bug where the first record in a headerless file may be
+   missed.
+
+ * Added an option to print header lines.
+
+ * Fixed a rare bug which may occasionally happen when retrieving data
+   from a region without any records.
+
+ * Enhanced error reporting.
+
+ * Fixed a bug in bgzip which may delete the original file even if not
+   intended.
+
+(0.2.3: 8 December 2010, r876)
+
+
+
+Beta Release 0.2.2 (28 June, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Dropped the VCF3 support. Added VCF4 support.
+
+ * Avoided the function name collision with samtools.
+
+(0.2.2: 28 June 2010, r603)
+
+
+
+Beta Release 0.2.1 (3 June, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Allow shared library to be compiled. Added python binding to the
+   shared library.
+
+(0.2.1: 3 June 2010, r582)
+
+
+
+Beta Release 0.2.0 (11 May, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Fixed an issue for random access given an interval end larger than
+   2^29.
+
+ * Updated the Java binding.
+
+ * Added a Perl module using XS.
+
+ * Improved the C APIs.
+
+(0.2.0: 11 May 2010, r574)
+
+
+
+Beta Release 0.1.6 (9 May, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Improved backward compatibility. Release 0.1.5 does not work with the
+   buggy index file generated by 0.1.2.
+
+ * Fixed a bug in building linear index. The bug does not affect the
+   results, only affects efficiency in rare cases.
+
+ * Reduced the number of seek calls given an index generated by old
+   version of tabix.
+
+ * Added new APIs for retrieving data via an iterator. The old callback
+   APIs are not changed, although internally it uses iterator to
+   retrieve data.
+
+I am trying to freeze tabix. I just hope I am committing new bugs.
+
+(0.1.6: 9 May 2010, r563)
+
+
+
+Beta Release 0.1.5 (5 May, 2010)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Notable changes:
+
+ * Clarified that tabix is released under MIT/X11.
+
+ * Improved the robustness of indexing and retrieval.
+
+ * Reduced the number of seek calls when the specified region starts
+   from a 16kb block with no data. The index format is the same, but the
+   content is changed a little.
+
+(0.1.5: 5 May 2010, r560)

data/ext/tabix/TabixReader.java

@@ -0,0 +1,395 @@
+/* The MIT License
+
+   Copyright (c) 2010 Broad 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.
+*/
+
+/* Contact: Heng Li <hengli@broadinstitute.org> */
+
+import net.sf.samtools.util.BlockCompressedInputStream;
+
+import java.io.*;
+import java.nio.*;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.lang.StringBuffer;
+
+public class TabixReader
+{
+	private String mFn;
+	private BlockCompressedInputStream mFp;
+
+	private int mPreset;
+	private int mSc;
+	private int mBc;
+	private int mEc;
+	private int mMeta;
+	private int mSkip;
+	private String[] mSeq;
+
+	private HashMap<String, Integer> mChr2tid;
+
+	private static int MAX_BIN = 37450;
+	private static int TAD_MIN_CHUNK_GAP = 32768;
+	private static int TAD_LIDX_SHIFT = 14;
+
+	private class TPair64 implements Comparable<TPair64> {
+		long u, v;
+		public TPair64(final long _u, final long _v) {
+			u = _u; v = _v;
+		}
+		public TPair64(final TPair64 p) {
+			u = p.u; v = p.v;
+		}
+		public int compareTo(final TPair64 p) {
+			return u == p.u? 0 : ((u < p.u) ^ (u < 0) ^ (p.u < 0))? -1 : 1; // unsigned 64-bit comparison
+		}
+	};
+
+	private class TIndex {
+		HashMap<Integer, TPair64[]> b; // binning index
+		long[] l; // linear index
+	};
+	private TIndex[] mIndex;
+
+	private class TIntv {
+		int tid, beg, end;
+	};
+
+	private static boolean less64(final long u, final long v) { // unsigned 64-bit comparison
+		return (u < v) ^ (u < 0) ^ (v < 0);
+	}
+
+	/**
+	 * The constructor
+	 *
+	 * @param fn File name of the data file
+	 */
+	public TabixReader(final String fn) throws IOException {
+		mFn = fn;
+		mFp = new BlockCompressedInputStream(new File(fn));
+		readIndex();
+	}
+
+	private static int reg2bins(final int beg, final int _end, final int[] list) {
+		int i = 0, k, end = _end;
+		if (beg >= end) return 0;
+		if (end >= 1<<29) end = 1<<29;
+		--end;
+		list[i++] = 0;
+		for (k =    1 + (beg>>26); k <=    1 + (end>>26); ++k) list[i++] = k;
+		for (k =    9 + (beg>>23); k <=    9 + (end>>23); ++k) list[i++] = k;
+		for (k =   73 + (beg>>20); k <=   73 + (end>>20); ++k) list[i++] = k;
+		for (k =  585 + (beg>>17); k <=  585 + (end>>17); ++k) list[i++] = k;
+		for (k = 4681 + (beg>>14); k <= 4681 + (end>>14); ++k) list[i++] = k;
+		return i;
+	}
+
+	public static int readInt(final InputStream is) throws IOException {
+		byte[] buf = new byte[4];
+		is.read(buf);
+		return ByteBuffer.wrap(buf).order(ByteOrder.LITTLE_ENDIAN).getInt();
+	}
+
+	public static long readLong(final InputStream is) throws IOException {
+		byte[] buf = new byte[8];
+		is.read(buf);
+		return ByteBuffer.wrap(buf).order(ByteOrder.LITTLE_ENDIAN).getLong();
+	}
+
+	public static String readLine(final InputStream is) throws IOException {
+		StringBuffer buf = new StringBuffer();
+		int c;
+		while ((c = is.read()) >= 0 && c != '\n')
+			buf.append((char)c);
+		if (c < 0) return null;
+		return buf.toString();
+	}
+
+	/**
+	 * Read the Tabix index from a file
+	 *
+	 * @param fp File pointer
+	 */
+	public void readIndex(final File fp) throws IOException {
+		if (fp == null) return;
+		BlockCompressedInputStream is = new BlockCompressedInputStream(fp);
+		byte[] buf = new byte[4];
+
+		is.read(buf, 0, 4); // read "TBI\1"
+		mSeq = new String[readInt(is)]; // # sequences
+		mChr2tid = new HashMap<String, Integer>();
+		mPreset = readInt(is);
+		mSc = readInt(is);
+		mBc = readInt(is);
+		mEc = readInt(is);
+		mMeta = readInt(is);
+		mSkip = readInt(is);
+		// read sequence dictionary
+		int i, j, k, l = readInt(is);
+		buf = new byte[l];
+		is.read(buf);
+		for (i = j = k = 0; i < buf.length; ++i) {
+			if (buf[i] == 0) {
+				byte[] b = new byte[i - j];
+				System.arraycopy(buf, j, b, 0, b.length);
+				String s = new String(b);
+				mChr2tid.put(s, k);
+				mSeq[k++] = s;
+				j = i + 1;
+			}
+		}
+		// read the index
+		mIndex = new TIndex[mSeq.length];
+		for (i = 0; i < mSeq.length; ++i) {
+			// the binning index
+			int n_bin = readInt(is);
+			mIndex[i] = new TIndex();
+			mIndex[i].b = new HashMap<Integer, TPair64[]>();
+			for (j = 0; j < n_bin; ++j) {
+				int bin = readInt(is);
+				TPair64[] chunks = new TPair64[readInt(is)];
+				for (k = 0; k < chunks.length; ++k) {
+					long u = readLong(is);
+					long v = readLong(is);
+					chunks[k] = new TPair64(u, v); // in C, this is inefficient
+				}
+				mIndex[i].b.put(bin, chunks);
+			}
+			// the linear index
+			mIndex[i].l = new long[readInt(is)];
+			for (k = 0; k < mIndex[i].l.length; ++k)
+				mIndex[i].l[k] = readLong(is);
+		}
+		// close
+		is.close();
+	}
+
+	/**
+	 * Read the Tabix index from the default file.
+	 */
+	public void readIndex() throws IOException {
+		readIndex(new File(mFn + ".tbi"));
+	}
+
+	/**
+	 * Read one line from the data file.
+	 */
+	public String readLine() throws IOException {
+		return readLine(mFp);
+	}
+
+	private int chr2tid(final String chr) {
+		if (mChr2tid.containsKey(chr)) return mChr2tid.get(chr);
+		else return -1;
+	}
+
+	/**
+	 * Parse a region in the format of "chr1", "chr1:100" or "chr1:100-1000"
+	 *
+	 * @param reg Region string
+	 * @return An array where the three elements are sequence_id,
+	 *         region_begin and region_end. On failure, sequence_id==-1.
+	 */
+	public int[] parseReg(final String reg) { // FIXME: NOT working when the sequence name contains : or -.
+		String chr;
+		int colon, hyphen;
+		int[] ret = new int[3];
+		colon = reg.indexOf(':'); hyphen = reg.indexOf('-');
+		chr = colon >= 0? reg.substring(0, colon) : reg;
+		ret[1] = colon >= 0? Integer.parseInt(reg.substring(colon+1, hyphen >= 0? hyphen : reg.length())) - 1 : 0;
+		ret[2] = hyphen >= 0? Integer.parseInt(reg.substring(hyphen+1)) : 0x7fffffff;
+		ret[0] = chr2tid(chr);
+		return ret;
+	}
+
+	private TIntv getIntv(final String s) {
+		TIntv intv = new TIntv();
+		int col = 0, end = 0, beg = 0;
+		while ((end = s.indexOf('\t', beg)) >= 0 || end == -1) {
+			++col;
+			if (col == mSc) {
+				intv.tid = chr2tid(s.substring(beg, end));
+			} else if (col == mBc) {
+				intv.beg = intv.end = Integer.parseInt(s.substring(beg, end));
+				if ((mPreset&0x10000) != 0) ++intv.end;
+				else --intv.beg;
+				if (intv.beg < 0) intv.beg = 0;
+				if (intv.end < 1) intv.end = 1;
+			} else { // FIXME: SAM supports are not tested yet
+				if ((mPreset&0xffff) == 0) { // generic
+					if (col == mEc)
+						intv.end = Integer.parseInt(s.substring(beg, end));
+				} else if ((mPreset&0xffff) == 1) { // SAM
+					if (col == 6) { // CIGAR
+						int l = 0, i, j;
+						String cigar = s.substring(beg, end);
+						for (i = j = 0; i < cigar.length(); ++i) {
+							if (cigar.charAt(i) > '9') {
+								int op = cigar.charAt(i);
+								if (op == 'M' || op == 'D' || op == 'N')
+									l += Integer.parseInt(cigar.substring(j, i));
+							}
+						}
+						intv.end = intv.beg + l;
+					}
+				} else if ((mPreset&0xffff) == 2) { // VCF
+					String alt;
+					alt = end >= 0? s.substring(beg, end) : s.substring(beg);
+					if (col == 4) { // REF
+						if (alt.length() > 0) intv.end = intv.beg + alt.length();
+					} else if (col == 8) { // INFO
+						int e_off = -1, i = alt.indexOf("END=");
+						if (i == 0) e_off = 4;
+						else if (i > 0) {
+							i = alt.indexOf(";END=");
+							if (i >= 0) e_off = i + 5;
+						}
+						if (e_off > 0) {
+							i = alt.indexOf(";", e_off);
+							intv.end = Integer.parseInt(i > e_off? alt.substring(e_off, i) : alt.substring(e_off));
+						}
+					}
+				}
+			}
+			if (end == -1) break;
+			beg = end + 1;
+		}
+		return intv;
+	}
+
+	public class Iterator {
+		private int i, n_seeks;
+		private int tid, beg, end;
+		private TPair64[] off;
+		private long curr_off;
+		private boolean iseof;
+
+		public Iterator(final int _tid, final int _beg, final int _end, final TPair64[] _off) {
+			i = -1; n_seeks = 0; curr_off = 0; iseof = false;
+			off = _off; tid = _tid; beg = _beg; end = _end;
+		}
+
+		public String next() throws IOException {
+			if (iseof) return null;
+			for (;;) {
+				if (curr_off == 0 || !less64(curr_off, off[i].v)) { // then jump to the next chunk
+					if (i == off.length - 1) break; // no more chunks
+					if (i >= 0) assert(curr_off == off[i].v); // otherwise bug
+					if (i < 0 || off[i].v != off[i+1].u) { // not adjacent chunks; then seek
+						mFp.seek(off[i+1].u);
+						curr_off = mFp.getFilePointer();
+						++n_seeks;
+					}
+					++i;
+				}
+				String s;
+				if ((s = readLine(mFp)) != null) {
+					TIntv intv;
+					char[] str = s.toCharArray();
+					curr_off = mFp.getFilePointer();
+					if (str.length == 0 || str[0] == mMeta) continue;
+					intv = getIntv(s);
+					if (intv.tid != tid || intv.beg >= end) break; // no need to proceed
+					else if (intv.end > beg && intv.beg < end) return s; // overlap; return
+				} else break; // end of file
+			}
+			iseof = true;
+			return null;
+		}
+	};
+
+	public Iterator query(final int tid, final int beg, final int end) {
+		TPair64[] off, chunks;
+		long min_off;
+		TIndex idx = mIndex[tid];
+		int[] bins = new int[MAX_BIN];
+		int i, l, n_off, n_bins = reg2bins(beg, end, bins);
+		if (idx.l.length > 0)
+			min_off = (beg>>TAD_LIDX_SHIFT >= idx.l.length)? idx.l[idx.l.length-1] : idx.l[beg>>TAD_LIDX_SHIFT];
+		else min_off = 0;
+		for (i = n_off = 0; i < n_bins; ++i) {
+			if ((chunks = idx.b.get(bins[i])) != null)
+				n_off += chunks.length;
+		}
+		if (n_off == 0) return null;
+		off = new TPair64[n_off];
+		for (i = n_off = 0; i < n_bins; ++i)
+			if ((chunks = idx.b.get(bins[i])) != null)
+				for (int j = 0; j < chunks.length; ++j)
+					if (less64(min_off, chunks[j].v))
+						off[n_off++] = new TPair64(chunks[j]);
+		if (n_off == 0) return null;
+		Arrays.sort(off, 0, n_off);
+		// resolve completely contained adjacent blocks
+		for (i = 1, l = 0; i < n_off; ++i) {
+			if (less64(off[l].v, off[i].v)) {
+				++l;
+				off[l].u = off[i].u; off[l].v = off[i].v;
+			}
+		}
+		n_off = l + 1;
+		// resolve overlaps between adjacent blocks; this may happen due to the merge in indexing
+		for (i = 1; i < n_off; ++i)
+			if (!less64(off[i-1].v, off[i].u)) off[i-1].v = off[i].u;
+		// merge adjacent blocks
+		for (i = 1, l = 0; i < n_off; ++i) {
+			if (off[l].v>>16 == off[i].u>>16) off[l].v = off[i].v;
+			else {
+				++l;
+				off[l].u = off[i].u;
+				off[l].v = off[i].v;
+			}
+		}
+		n_off = l + 1;
+		// return
+		TPair64[] ret = new TPair64[n_off];
+		for (i = 0; i < n_off; ++i) ret[i] = new TPair64(off[i].u, off[i].v); // in C, this is inefficient
+		return new TabixReader.Iterator(tid, beg, end, ret);
+	}
+	
+	public Iterator query(final String reg) {
+		int[] x = parseReg(reg);
+		return query(x[0], x[1], x[2]);
+	}
+
+	public static void main(String[] args) {
+		if (args.length < 1) {
+			System.out.println("Usage: java -cp .:sam.jar TabixReader <in.gz> [region]");
+			System.exit(1);
+		}
+		try {
+			TabixReader tr = new TabixReader(args[0]);
+			String s;
+			if (args.length == 1) { // no region is specified; print the whole file
+				while ((s = tr.readLine()) != null)
+					System.out.println(s);
+			} else { // a region is specified; random access
+				TabixReader.Iterator iter = tr.query(args[1]); // get the iterator
+				while (iter != null && (s = iter.next()) != null)
+					System.out.println(s);
+			}
+		} catch (IOException e) {
+		}
+	}
+}

data/ext/tabix/bam_endian.h

@@ -0,0 +1,42 @@
+#ifndef BAM_ENDIAN_H
+#define BAM_ENDIAN_H
+
+#include <stdint.h>
+
+static inline int bam_is_big_endian()
+{
+	long one= 1;
+	return !(*((char *)(&one)));
+}
+static inline uint16_t bam_swap_endian_2(uint16_t v)
+{
+	return (uint16_t)(((v & 0x00FF00FFU) << 8) | ((v & 0xFF00FF00U) >> 8));
+}
+static inline void *bam_swap_endian_2p(void *x)
+{
+	*(uint16_t*)x = bam_swap_endian_2(*(uint16_t*)x);
+	return x;
+}
+static inline uint32_t bam_swap_endian_4(uint32_t v)
+{
+	v = ((v & 0x0000FFFFU) << 16) | (v >> 16);
+	return ((v & 0x00FF00FFU) << 8) | ((v & 0xFF00FF00U) >> 8);
+}
+static inline void *bam_swap_endian_4p(void *x)
+{
+	*(uint32_t*)x = bam_swap_endian_4(*(uint32_t*)x);
+	return x;
+}
+static inline uint64_t bam_swap_endian_8(uint64_t v)
+{
+	v = ((v & 0x00000000FFFFFFFFLLU) << 32) | (v >> 32);
+	v = ((v & 0x0000FFFF0000FFFFLLU) << 16) | ((v & 0xFFFF0000FFFF0000LLU) >> 16);
+	return ((v & 0x00FF00FF00FF00FFLLU) << 8) | ((v & 0xFF00FF00FF00FF00LLU) >> 8);
+}
+static inline void *bam_swap_endian_8p(void *x)
+{
+	*(uint64_t*)x = bam_swap_endian_8(*(uint64_t*)x);
+	return x;
+}
+
+#endif

data/ext/tabix/bedidx.c

@@ -0,0 +1,156 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <zlib.h>
+
+#include "ksort.h"
+KSORT_INIT_GENERIC(uint64_t)
+
+#include "kseq.h"
+KSTREAM_INIT(gzFile, gzread, 8192)
+
+typedef struct {
+	int n, m;
+	uint64_t *a;
+	int *idx;
+} bed_reglist_t;
+
+#include "khash.h"
+KHASH_MAP_INIT_STR(reg, bed_reglist_t)
+
+#define LIDX_SHIFT 13
+
+typedef kh_reg_t reghash_t;
+
+int *bed_index_core(int n, uint64_t *a, int *n_idx)
+{
+	int i, j, m, *idx;
+	m = *n_idx = 0; idx = 0;
+	for (i = 0; i < n; ++i) {
+		int beg, end;
+		beg = a[i]>>32 >> LIDX_SHIFT; end = ((uint32_t)a[i]) >> LIDX_SHIFT;
+		if (m < end + 1) {
+			int oldm = m;
+			m = end + 1;
+			kroundup32(m);
+			idx = realloc(idx, m * sizeof(int));
+			for (j = oldm; j < m; ++j) idx[j] = -1;
+		}
+		if (beg == end) {
+			if (idx[beg] < 0) idx[beg] = i;
+		} else {
+			for (j = beg; j <= end; ++j)
+				if (idx[j] < 0) idx[j] = i;
+		}
+		*n_idx = end + 1;
+	}
+	return idx;
+}
+
+void bed_index(void *_h)
+{
+	reghash_t *h = (reghash_t*)_h;
+	khint_t k;
+	for (k = 0; k < kh_end(h); ++k) {
+		if (kh_exist(h, k)) {
+			bed_reglist_t *p = &kh_val(h, k);
+			if (p->idx) free(p->idx);
+			ks_introsort(uint64_t, p->n, p->a);
+			p->idx = bed_index_core(p->n, p->a, &p->m);
+		}
+	}
+}
+
+int bed_overlap_core(const bed_reglist_t *p, int beg, int end)
+{
+	int i, min_off;
+	if (p->n == 0) return 0;
+	min_off = (beg>>LIDX_SHIFT >= p->n)? p->idx[p->n-1] : p->idx[beg>>LIDX_SHIFT];
+	if (min_off < 0) { // TODO: this block can be improved, but speed should not matter too much here
+		int n = beg>>LIDX_SHIFT;
+		if (n > p->n) n = p->n;
+		for (i = n - 1; i >= 0; --i)
+			if (p->idx[i] >= 0) break;
+		min_off = i >= 0? p->idx[i] : 0;
+	}
+	for (i = min_off; i < p->n; ++i) {
+		if ((int)(p->a[i]>>32) >= end) break; // out of range; no need to proceed
+		if ((int32_t)p->a[i] > beg && (int32_t)(p->a[i]>>32) < end)
+			return 1; // find the overlap; return
+	}
+	return 0;
+}
+
+int bed_overlap(const void *_h, const char *chr, int beg, int end)
+{
+	const reghash_t *h = (const reghash_t*)_h;
+	khint_t k;
+	if (!h) return 0;
+	k = kh_get(reg, h, chr);
+	if (k == kh_end(h)) return 0;
+	return bed_overlap_core(&kh_val(h, k), beg, end);
+}
+
+void *bed_read(const char *fn)
+{
+	reghash_t *h = kh_init(reg);
+	gzFile fp;
+	kstream_t *ks;
+	int dret;
+	kstring_t *str;
+	// read the list
+	fp = strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
+	if (fp == 0) return 0;
+	str = calloc(1, sizeof(kstring_t));
+	ks = ks_init(fp);
+	while (ks_getuntil(ks, 0, str, &dret) >= 0) { // read the chr name
+		int beg = -1, end = -1;
+		bed_reglist_t *p;
+		khint_t k = kh_get(reg, h, str->s);
+		if (k == kh_end(h)) { // absent from the hash table
+			int ret;
+			char *s = strdup(str->s);
+			k = kh_put(reg, h, s, &ret);
+			memset(&kh_val(h, k), 0, sizeof(bed_reglist_t));
+		}
+		p = &kh_val(h, k);
+		if (dret != '\n') { // if the lines has other characters
+			if (ks_getuntil(ks, 0, str, &dret) > 0 && isdigit(str->s[0])) {
+				beg = atoi(str->s); // begin
+				if (dret != '\n') {
+					if (ks_getuntil(ks, 0, str, &dret) > 0 && isdigit(str->s[0]))
+						end = atoi(str->s); // end
+				}
+			}
+		}
+		if (dret != '\n') while ((dret = ks_getc(ks)) > 0 && dret != '\n'); // skip the rest of the line
+		if (end < 0 && beg > 0) end = beg, beg = beg - 1; // if there is only one column
+		if (beg >= 0 && end > beg) {
+			if (p->n == p->m) {
+				p->m = p->m? p->m<<1 : 4;
+				p->a = realloc(p->a, p->m * 8);
+			}
+			p->a[p->n++] = (uint64_t)beg<<32 | end;
+		}
+	}
+	ks_destroy(ks);
+	gzclose(fp);
+	free(str->s); free(str);
+	bed_index(h);
+	return h;
+}
+
+void bed_destroy(void *_h)
+{
+	reghash_t *h = (reghash_t*)_h;
+	khint_t k;
+	for (k = 0; k < kh_end(h); ++k) {
+		if (kh_exist(h, k)) {
+			free(kh_val(h, k).a);
+			free(kh_val(h, k).idx);
+			free((char*)kh_key(h, k));
+		}
+	}
+	kh_destroy(reg, h);
+}