minibwa 0.0.0

data/ext/minibwa/minibwa/ketopt.h

@@ -0,0 +1,123 @@
+#ifndef KETOPT_H
+#define KETOPT_H
+
+#include <string.h> /* for strchr() and strncmp() */
+
+#define ko_no_argument       0
+#define ko_required_argument 1
+#define ko_optional_argument 2
+
+typedef struct {
+	int ind;   /* equivalent to optind */
+	int opt;   /* equivalent to optopt */
+	char *arg; /* equivalent to optarg */
+	int longidx; /* index of a long option; or -1 if short */
+	/* private variables not intended for external uses */
+	int i, pos, n_args;
+} ketopt_t;
+
+typedef struct {
+	char *name;
+	int has_arg;
+	int val;
+} ko_longopt_t;
+
+static ketopt_t KETOPT_INIT = { 1, 0, 0, -1, 1, 0, 0 };
+
+static void ketopt_permute(char *argv[], int j, int n) /* move argv[j] over n elements to the left */
+{
+	int k;
+	char *p = argv[j];
+	for (k = 0; k < n; ++k)
+		argv[j - k] = argv[j - k - 1];
+	argv[j - k] = p;
+}
+
+/**
+ * Parse command-line options and arguments
+ *
+ * This fuction has a similar interface to GNU's getopt_long(). Each call
+ * parses one option and returns the option name.  s->arg points to the option
+ * argument if present. The function returns -1 when all command-line arguments
+ * are parsed. In this case, s->ind is the index of the first non-option
+ * argument.
+ *
+ * @param s         status; shall be initialized to KETOPT_INIT on the first call
+ * @param argc      length of argv[]
+ * @param argv      list of command-line arguments; argv[0] is ignored
+ * @param permute   non-zero to move options ahead of non-option arguments
+ * @param ostr      option string
+ * @param longopts  long options
+ *
+ * @return ASCII for a short option; ko_longopt_t::val for a long option; -1 if
+ *         argv[] is fully processed; '?' for an unknown option or an ambiguous
+ *         long option; ':' if an option argument is missing
+ */
+static int ketopt(ketopt_t *s, int argc, char *argv[], int permute, const char *ostr, const ko_longopt_t *longopts)
+{
+	int opt = -1, i0, j;
+	if (permute) {
+		while (s->i < argc && (argv[s->i][0] != '-' || argv[s->i][1] == '\0'))
+			++s->i, ++s->n_args;
+	}
+	s->arg = 0, s->longidx = -1, i0 = s->i;
+	if (s->i >= argc || argv[s->i][0] != '-' || argv[s->i][1] == '\0') {
+		s->ind = s->i - s->n_args;
+		return -1;
+	}
+	if (argv[s->i][0] == '-' && argv[s->i][1] == '-') { /* "--" or a long option */
+		if (argv[s->i][2] == '\0') { /* a bare "--" */
+			ketopt_permute(argv, s->i, s->n_args);
+			++s->i, s->ind = s->i - s->n_args;
+			return -1;
+		}
+		s->opt = 0, opt = '?', s->pos = -1;
+		if (longopts) { /* parse long options */
+			int k, n_exact = 0, n_partial = 0;
+			const ko_longopt_t *o = 0, *o_exact = 0, *o_partial = 0;
+			for (j = 2; argv[s->i][j] != '\0' && argv[s->i][j] != '='; ++j) {} /* find the end of the option name */
+			for (k = 0; longopts[k].name != 0; ++k)
+				if (strncmp(&argv[s->i][2], longopts[k].name, j - 2) == 0) {
+					if (longopts[k].name[j - 2] == 0) ++n_exact, o_exact = &longopts[k];
+					else ++n_partial, o_partial = &longopts[k];
+				}
+			if (n_exact > 1 || (n_exact == 0 && n_partial > 1)) {
+				s->i++;
+				return '?';
+			}
+			o = n_exact == 1? o_exact : n_partial == 1? o_partial : 0;
+			if (o) {
+				s->opt = opt = o->val, s->longidx = o - longopts;
+				if (argv[s->i][j] == '=') s->arg = &argv[s->i][j + 1];
+				if (o->has_arg == 1 && argv[s->i][j] == '\0') {
+					if (s->i < argc - 1) s->arg = argv[++s->i];
+					else opt = ':'; /* missing option argument */
+				}
+			}
+		}
+	} else { /* a short option */
+		char *p;
+		if (s->pos == 0) s->pos = 1;
+		opt = s->opt = argv[s->i][s->pos++];
+		p = strchr((char*)ostr, opt);
+		if (p == 0) {
+			opt = '?'; /* unknown option */
+		} else if (p[1] == ':') {
+			if (argv[s->i][s->pos] == 0) {
+				if (s->i < argc - 1) s->arg = argv[++s->i];
+				else opt = ':'; /* missing option argument */
+			} else s->arg = &argv[s->i][s->pos];
+			s->pos = -1;
+		}
+	}
+	if (s->pos < 0 || argv[s->i][s->pos] == 0) {
+		++s->i, s->pos = 0;
+		if (s->n_args > 0) /* permute */
+			for (j = i0; j < s->i; ++j)
+				ketopt_permute(argv, j, s->n_args);
+	}
+	s->ind = s->i - s->n_args;
+	return opt;
+}
+
+#endif

data/ext/minibwa/minibwa/kommon.c

@@ -0,0 +1,374 @@
+#define _DEFAULT_SOURCE // expose MADV_RANDOM etc. under -std=c99 (glibc >= 2.19)
+#define _BSD_SOURCE     // ditto on older glibc (e.g. CentOS 7 / glibc 2.17)
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include "kommon.h"
+
+int kom_verbose = 3, kom_dbg = 0, kom_dbg_flag = 0;
+
+char *kom_strdup(const char *src) // strdup() doesn't conform to C99
+{
+	size_t len;
+	char *dst;
+	len = strlen(src);
+	dst = kom_malloc(char, len + 1);
+	memcpy(dst, src, len + 1);
+	return dst;
+}
+
+int64_t kom_parse_num(const char *str, char **q)
+{
+	double x;
+	char *p;
+	x = strtod(str, &p);
+	if (*p == 'G' || *p == 'g') x *= 1e9, ++p;
+	else if (*p == 'M' || *p == 'm') x *= 1e6, ++p;
+	else if (*p == 'K' || *p == 'k') x *= 1e3, ++p;
+	if (q) *q = p;
+	return (int64_t)(x + .499);
+}
+
+void kom_panic(const char *func, const char *msg)
+{
+	fprintf(stderr, "[E::%s] %s ABORT!\n", func, msg);
+	abort();
+}
+
+/****************
+ * Fast sprintf *
+ ****************/
+
+#ifdef HAVE_KALLOC
+#include "kalloc.h"
+#endif
+
+static inline void str_enlarge(void *km, kstring_t *s, int l)
+{
+	if (s->l + l + 1 > s->m) {
+		s->m = s->l + l + 1;
+		kom_roundup64(s->m);
+#ifdef HAVE_KALLOC
+		s->s = Krealloc(km, char, s->s, s->m);
+#else
+		s->s = kom_realloc(char, s->s, s->m);
+#endif
+	}
+}
+
+static inline void str_copy(void *km, kstring_t *s, const char *st, const char *en)
+{
+	str_enlarge(km, s, en - st);
+	memcpy(&s->s[s->l], st, en - st);
+	s->l += en - st;
+}
+
+int64_t kom_sprintf_lite_core(void *km, kstring_t *s, const char *fmt, va_list ap)
+{
+	char buf[32]; // for integer to string conversion
+	const char *p, *q;
+	int64_t len = 0;
+	for (q = p = fmt; *p; ++p) {
+		if (*p == '%') {
+			if (p > q) {
+				len += p - q;
+				if (s) str_copy(km, 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++] = '-';
+				len += l;
+				if (s) {
+					str_enlarge(km, s, l);
+					for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
+				}
+			} else if (*p == 'l' && *(p+1) == 'd') {
+				int i, l = 0;
+				long c;
+				unsigned long x;
+				c = va_arg(ap, long);
+				x = c >= 0? c : -c;
+				do { buf[l++] = x%10 + '0'; x /= 10; } while (x > 0);
+				if (c < 0) buf[l++] = '-';
+				len += l;
+				if (s) {
+					str_enlarge(km, s, l);
+					for (i = l - 1; i >= 0; --i) s->s[s->l++] = buf[i];
+				}
+				++p;
+			} 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);
+				len += l;
+				if (s) {
+					str_enlarge(km, 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*);
+				int l;
+				l = strlen(r);
+				len += l;
+				if (s) str_copy(km, s, r, r + l);
+			} else if (*p == 'c') {
+				++len;
+				if (s) {
+					str_enlarge(km, s, 1);
+					s->s[s->l++] = va_arg(ap, int);
+				}
+			} else {
+				fprintf(stderr, "ERROR: unrecognized type '%%%c'\n", *p);
+				abort();
+			}
+			q = p + 1;
+		}
+	}
+	if (p > q) {
+		len += p - q;
+		if (s) str_copy(km, s, q, p);
+	}
+	if (s) s->s[s->l] = 0;
+	return len;
+}
+
+int64_t kom_sprintf_lite(kstring_t *s, const char *fmt, ...)
+{
+	int64_t ret;
+	va_list ap;
+	va_start(ap, fmt); ret = kom_sprintf_lite_core(0, s, fmt, ap); va_end(ap);
+	return ret;
+}
+
+int64_t km_sprintf_lite(void *km, kstring_t *s, const char *fmt, ...)
+{
+	int64_t ret;
+	va_list ap;
+	va_start(ap, fmt); ret = kom_sprintf_lite_core(km, s, fmt, ap); va_end(ap);
+	return ret;
+}
+
+/****************
+ * DNA sequence *
+ ****************/
+
+uint8_t kom_nt4_table[256] = {
+	0, 1, 2, 3,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 0, 4, 1,  4, 4, 4, 2,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  3, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 0, 4, 1,  4, 4, 4, 2,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  3, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4, 
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4
+};
+
+uint8_t kom_comp_table[256] = {
+	  3,   2,	1,	 0,	  4,   5,	6,	 7,	  8,   9,  10,	11,	 12,  13,  14,	15,
+	 16,  17,  18,	19,	 20,  21,  22,	23,	 24,  25,  26,	27,	 28,  29,  30,	31,
+	 32,  33,  34,	35,	 36,  37,  38,	39,	 40,  41,  42,	43,	 44,  45,  46,	47,
+	 48,  49,  50,	51,	 52,  53,  54,	55,	 56,  57,  58,	59,	 60,  61,  62,	63,
+	 64, 'T', 'V', 'G', 'H', 'E', 'F', 'C', 'D', 'I', 'J', 'M', 'L', 'K', 'N', 'O',
+	'P', 'Q', 'Y', 'S', 'A', 'A', 'B', 'W', 'X', 'R', 'Z',	91,	 92,  93,  94,	95,
+	 96, 't', 'v', 'g', 'h', 'e', 'f', 'c', 'd', 'i', 'j', 'm', 'l', 'k', 'n', 'o',
+	'p', 'q', 'y', 's', 'a', 'a', 'b', 'w', 'x', 'r', 'z', 123, 124, 125, 126, 127,
+	128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+	144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+	160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+	176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+	192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+	208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+	224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+	240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
+};
+
+void kom_revcomp(uint64_t len, char *seq) // reverse complement in place
+{
+	uint64_t i;
+	for (i = 0; i < len>>1; ++i) {
+		uint8_t t = seq[len - i - 1];
+		seq[len - i - 1] = kom_comp_table[(uint8_t)seq[i]];
+		seq[i] = kom_comp_table[t];
+	}
+	if (len&1) seq[len>>1] = kom_comp_table[(uint8_t)seq[len>>1]];
+}
+
+/***********************
+ * Timing and peak RSS *
+ ***********************/
+
+#if defined(WIN32) || defined(_WIN32)
+#include <windows.h>
+
+struct timezone
+{
+	__int32  tz_minuteswest; /* minutes W of Greenwich */
+	int  tz_dsttime;     /* type of dst correction */
+};
+
+/*
+ * gettimeofday.c
+ *    Win32 gettimeofday() replacement
+ *    taken from PostgreSQL, according to
+ *    https://stackoverflow.com/questions/1676036/what-should-i-use-to-replace-gettimeofday-on-windows
+ *
+ * src/port/gettimeofday.c
+ *
+ * Copyright (c) 2003 SRA, Inc.
+ * Copyright (c) 2003 SKC, Inc.
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose, without fee, and without a
+ * written agreement is hereby granted, provided that the above
+ * copyright notice and this paragraph and the following two
+ * paragraphs appear in all copies.
+ *
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
+ * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
+ * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+ * DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS
+ * IS" BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE,
+ * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ */
+
+/* FILETIME of Jan 1 1970 00:00:00. */
+static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
+
+/*
+ * timezone information is stored outside the kernel so tzp isn't used anymore.
+ *
+ * Note: this function is not for Win32 high precision timing purpose. See
+ * elapsed_time().
+ */
+int gettimeofday(struct timeval * tp, struct timezone *tzp)
+{
+	FILETIME    file_time;
+	SYSTEMTIME  system_time;
+	ULARGE_INTEGER ularge;
+
+	GetSystemTime(&system_time);
+	SystemTimeToFileTime(&system_time, &file_time);
+	ularge.LowPart = file_time.dwLowDateTime;
+	ularge.HighPart = file_time.dwHighDateTime;
+
+	tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
+	tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
+
+	return 0;
+}
+
+// taken from https://stackoverflow.com/questions/5272470/c-get-cpu-usage-on-linux-and-windows
+double kom_cputime()
+{
+	HANDLE hProcess = GetCurrentProcess();
+	FILETIME ftCreation, ftExit, ftKernel, ftUser;
+	SYSTEMTIME stKernel;
+	SYSTEMTIME stUser;
+
+	GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
+	FileTimeToSystemTime(&ftKernel, &stKernel);
+	FileTimeToSystemTime(&ftUser, &stUser);
+
+	double kernelModeTime = ((stKernel.wHour * 60.) + stKernel.wMinute * 60.) + stKernel.wSecond * 1. + stKernel.wMilliseconds / 1000.;
+	double userModeTime = ((stUser.wHour * 60.) + stUser.wMinute * 60.) + stUser.wSecond * 1. + stUser.wMilliseconds / 1000.;
+
+	return kernelModeTime + userModeTime;
+}
+
+long kom_peakrss(void) { return 0; }
+#else
+#include <sys/resource.h>
+#include <sys/time.h>
+
+double kom_cputime(void)
+{
+	struct rusage r;
+	getrusage(RUSAGE_SELF, &r);
+	return r.ru_utime.tv_sec + r.ru_stime.tv_sec + 1e-6 * (r.ru_utime.tv_usec + r.ru_stime.tv_usec);
+}
+
+long kom_peakrss(void)
+{
+	struct rusage r;
+	getrusage(RUSAGE_SELF, &r);
+#ifdef __linux__
+	return r.ru_maxrss * 1024;
+#else
+	return r.ru_maxrss;
+#endif
+}
+
+#endif /* WIN32 || _WIN32 */
+
+double kom_realtime(void)
+{
+	static double realtime0 = -1.0;
+	struct timeval tp;
+	double t;
+	gettimeofday(&tp, NULL);
+	t = tp.tv_sec + tp.tv_usec * 1e-6;
+	if (realtime0 < 0.0) realtime0 = t;
+	return t - realtime0;
+}
+
+double kom_percent_cpu(void)
+{
+	return (kom_cputime() + 1e-6) / (kom_realtime() + 1e-6);
+}
+
+/***************
+ * mmap loader *
+ ***************/
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+void *kom_mmap_file(const char *fn, size_t *len, int preload)
+{
+	int fd, mmap_flags = MAP_SHARED;
+	struct stat st;
+	uint8_t *base;
+
+	*len = 0;
+	fd = open(fn, O_RDONLY);
+	if (fd < 0) return 0;
+	if (fstat(fd, &st) < 0 || st.st_size == 0) { close(fd); return 0; }
+	*len = st.st_size;
+#ifdef MAP_POPULATE // this is Linux only
+	if (preload) mmap_flags |= MAP_POPULATE;
+#endif
+	base = (uint8_t*)mmap(0, *len, PROT_READ, mmap_flags, fd, 0);
+	close(fd);
+	if (base == MAP_FAILED) return 0;
+#ifdef MADV_RANDOM
+	madvise(base, *len, MADV_RANDOM);
+#endif
+	return base;
+}
+
+int kom_munmap(void *base, size_t map_len) // a simple wrapper
+{
+	return munmap(base, map_len);
+}

data/ext/minibwa/minibwa/kommon.h

@@ -0,0 +1,85 @@
+#ifndef HL_HEADER
+#define HL_HEADER
+
+#include <stdint.h>
+
+#define kom_malloc(type, cnt)       ((type*)malloc((cnt) * sizeof(type)))
+#define kom_calloc(type, cnt)       ((type*)calloc((cnt), sizeof(type)))
+#define kom_realloc(type, ptr, cnt) ((type*)realloc((ptr), (cnt) * sizeof(type)))
+
+// make enough room to write ptr[i]
+#define kom_grow(type, ptr, __i, __m) do { \
+		if ((__i) >= (__m)) { \
+			(__m) = (__i) + 1; \
+			(__m) += ((__m)>>1) + 16; \
+			(ptr) = kom_realloc(type, (ptr), (__m)); \
+		} \
+	} while (0)
+
+#define kom_roundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#define kom_roundup64(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, (x)|=(x)>>32, ++(x))
+
+#define kom_reverse(type, n, a) do { \
+		size_t i; \
+		for (i = 0; i < (n)>>1; ++i) { \
+			type t = a[(n) - 1 - i]; \
+			a[(n) - 1 - i] = a[i], a[i] = t; \
+		} \
+	} while (0)
+
+#define kom_assert(cond, msg) if ((cond) == 0) kom_panic(__func__, (msg))
+
+#ifndef KSTRING_T
+#define KSTRING_T kstring_t
+typedef struct {
+	size_t l, m;
+	char *s;
+} kstring_t;
+#endif
+
+typedef struct { uint64_t x, y; } kom128_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int kom_verbose, kom_dbg, kom_dbg_flag;
+
+char *kom_strdup(const char *src);
+int64_t kom_parse_num(const char *str, char **q);
+void kom_panic(const char *func, const char *msg);
+
+int64_t kom_sprintf_lite(kstring_t *s, const char *fmt, ...);
+int64_t km_sprintf_lite(void *km, kstring_t *s, const char *fmt, ...);
+
+double kom_cputime(void);
+double kom_realtime(void); // call at the beginning to reset the timer
+long kom_peakrss(void);
+double kom_percent_cpu(void);
+
+void *kom_mmap_file(const char *fn, size_t *len, int preload);
+int kom_munmap(void *base, size_t map_len);
+
+extern uint8_t kom_nt4_table[256], kom_comp_table[256];
+void kom_revcomp(uint64_t len, char *seq);
+
+static inline uint64_t kom_splitmix64(uint64_t *x)
+{
+	uint64_t z = ((*x) += 0x9e3779b97f4a7c15ULL);
+	z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9ULL;
+	z = (z ^ (z >> 27)) * 0x94d049bb133111ebULL;
+	return z ^ (z >> 31);
+}
+
+static inline double kom_u64todbl(uint64_t x)
+{
+	union { uint64_t i; double d; } u;
+	u.i = 0x3FFULL << 52 | x >> 12;
+	return u.d - 1.0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // ~HL_HEADER