Add files using upload-large-folder tool

falcon/lib/python3.10/site-packages/pysam/include/bcftools/call.h

@@ -0,0 +1,149 @@
+/*  call.h -- variant calling declarations.
+
+    Copyright (C) 2013-2015, 2019-2020 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#ifndef __CALL_H__
+#define __CALL_H__
+
+#include <htslib/vcf.h>
+#include <htslib/synced_bcf_reader.h>
+#include "vcmp.h"
+
+#define CALL_KEEPALT        1
+#define CALL_VARONLY        (1<<1)
+#define CALL_CONSTR_TRIO    (1<<2)
+#define CALL_CONSTR_ALLELES (1<<3)
+//
+#define CALL_FMT_PV4        (1<<5)
+#define CALL_FMT_GQ         (1<<6)
+#define CALL_FMT_GP         (1<<7)
+
+#define FATHER 0
+#define MOTHER 1
+#define CHILD  2
+typedef struct
+{
+    char *name;
+    int sample[3];  // father, mother, child
+    int type;       // see FTYPE_* definitions in mcall.c
+}
+family_t;
+
+// For the single-sample and grouped -G calling
+typedef struct
+{
+    double ref_lk, max_lk, lk_sum;
+    float *qsum;    // QS(quality sum) values
+    int nqsum;
+    uint32_t *smpl, nsmpl;
+    uint32_t nals, als;
+}
+smpl_grp_t;
+
+// For the `-C alleles -i` constrained calling
+typedef struct
+{
+    uint32_t n:31, used:1;
+    char **allele;
+}
+tgt_als_t;
+
+typedef struct _ccall_t ccall_t;
+typedef struct
+{
+    // mcall only
+    int npdg;
+    int *als_map, nals_map; // mapping from full set of alleles to trimmed set of alleles (old -> new)
+    int *pl_map, npl_map;   // same as above for PLs, but reverse (new -> old)
+    char **als;             // array to hold the trimmed set of alleles to appear on output
+    int nals;               // size of the als array
+    int als_new, nals_new;  // bitmask with final alleles and their number
+    family_t *fams;         // list of families and samples for trio calling
+    int nfams, mfams;
+    int ntrio[5][5];        // possible trio genotype combinations and their counts; first idx:
+    uint16_t *trio[5][5];   //  family type, second index: allele count (2-4, first two are unused)
+    double *GLs;
+    float *GPs;             // FORMAT/GP: posterior probabilities
+    int32_t *GQs, *ADs;     // FORMAT/GQ: genotype qualities; AD: allelic depth for -G
+    int32_t *itmp;          // temporary int array, used for new PLs with CALL_CONSTR_ALLELES
+    int n_itmp, nGPs, nADs;
+    vcmp_t *vcmp;
+    double trio_Pm_SNPs, trio_Pm_del, trio_Pm_ins;      // P(mendelian) for trio calling, see mcall_call_trio_genotypes()
+    int32_t *ugts, *cgts;   // unconstraind and constrained GTs
+    uint32_t output_tags;
+    char *prior_AN, *prior_AC;  // reference panel AF tags (AF=AC/AN)
+    tgt_als_t *tgt_als;         // for CALL_CONSTR_ALLELES
+    char *sample_groups;        // for single-sample or grouped calling with -G
+    char *sample_groups_tag;    // for -G [AD|QS:]
+    smpl_grp_t *smpl_grp;
+    int nsmpl_grp;
+
+    // ccall only
+    double indel_frac, min_perm_p, min_lrt;
+    double prior_type, pref;
+    int ngrp1_samples, n_perm;
+    char *prior_file;
+    ccall_t *cdat;
+
+    // shared
+    bcf_srs_t *srs;         // BCF synced readers holding target alleles for CALL_CONSTR_ALLELES
+    bcf1_t *rec;
+    bcf_hdr_t *hdr;
+    uint32_t flag;          // One or more of the CALL_* flags defined above
+    uint8_t *ploidy, all_diploid, unseen;
+
+    double pl2p[256];       // PL to 10^(-PL/10) table
+    int32_t *PLs;           // VCF PL likelihoods (rw)
+    int nPLs, mPLs, nac;
+    int32_t *gts, *ac;      // GTs and AC (w)
+    double *pdg;            // PLs converted to P(D|G)
+    float *anno16; int n16; // see anno[16] in bam2bcf.h
+    double theta;           // prior
+}
+call_t;
+
+void error(const char *format, ...);
+
+/*
+ *  call() - return -1 value on critical error; -2 to skip the site; or the number of non-reference
+ *            alleles on success.
+ */
+int mcall(call_t *call, bcf1_t *rec);    // multiallic and rare-variant calling model
+int ccall(call_t *call, bcf1_t *rec);    // the default consensus calling model
+int qcall(call_t *call, bcf1_t *rec);    // QCall output
+
+void mcall_init(call_t *call);
+void ccall_init(call_t *call);
+void qcall_init(call_t *call);
+
+void mcall_destroy(call_t *call);
+void ccall_destroy(call_t *call);
+void qcall_destroy(call_t *call);
+
+void call_init_pl2p(call_t *call);
+uint32_t *call_trio_prep(int is_x, int is_son);
+
+void init_allele_trimming_maps(call_t *call, int nals_ori, int als_out);
+void mcall_trim_and_update_numberR(call_t *call, bcf1_t *rec, int nals_ori, int nals_new);
+
+#endif

falcon/lib/python3.10/site-packages/pysam/include/bcftools/ccall.c.pysam.c

@@ -0,0 +1,340 @@
+#include "bcftools.pysam.h"
+
+/*  ccall.c -- consensus variant calling.
+
+    Copyright (C) 2013-2014 Genome Research Ltd.
+    Portions copyright (C) 2010 Broad Institute.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#include <math.h>
+#include <assert.h>
+#include <htslib/kfunc.h>
+#include "call.h"
+#include "kmin.h"
+#include "prob1.h"
+
+// Most of the original -c calling was moved to bcftools as it was
+// and its data structures were wrapped into the ccal_t to make it
+// functional quickly. This is not the desired state.
+struct _ccall_t
+{
+    bcf_p1aux_t *p1;
+};
+
+void ccall_init(call_t *call)
+{
+    call->cdat = (ccall_t*) calloc(1,sizeof(ccall_t));
+    call_init_pl2p(call);
+    call->cdat->p1 = bcf_p1_init(bcf_hdr_nsamples(call->hdr), call->ploidy);
+    call->gts = (int*) calloc(bcf_hdr_nsamples(call->hdr)*2,sizeof(int));   // assuming at most diploid everywhere
+    call->nals_map = 5;
+    call->als_map  = (int*) malloc(sizeof(int)*call->nals_map);
+
+    bcf_hdr_append(call->hdr,"##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">");
+    if ( call->output_tags & CALL_FMT_GQ )
+    {
+        bcf_hdr_append(call->hdr,"##FORMAT=<ID=GQ,Number=1,Type=Integer,Description=\"Genotype Quality\">");
+        call->GQs = (int32_t*) malloc(sizeof(int32_t)*bcf_hdr_nsamples(call->hdr));
+    }
+    if ( call->output_tags & CALL_FMT_GP )
+        error("Sorry, -f GP is not supported with -c\n");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=AF1,Number=1,Type=Float,Description=\"Max-likelihood estimate of the first ALT allele frequency (assuming HWE)\">");
+    // Todo: groups not migrated to 'bcftools call' yet
+    bcf_hdr_append(call->hdr,"##INFO=<ID=AF2,Number=1,Type=Float,Description=\"Max-likelihood estimate of the first and second group ALT allele frequency (assuming HWE)\">");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=AC1,Number=1,Type=Float,Description=\"Max-likelihood estimate of the first ALT allele count (no HWE assumption)\">");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=MQ,Number=1,Type=Integer,Description=\"Root-mean-square mapping quality of covering reads\">\n");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=FQ,Number=1,Type=Float,Description=\"Phred probability of all samples being the same\">\n");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=PV4,Number=4,Type=Float,Description=\"P-values for strand bias, baseQ bias, mapQ bias and tail distance bias\">\n");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=G3,Number=3,Type=Float,Description=\"ML estimate of genotype frequencies\">\n");
+    bcf_hdr_append(call->hdr,"##INFO=<ID=HWE,Number=1,Type=Float,Description=\"Chi^2 based HWE test P-value based on G3\">\n");
+    // bcf_hdr_append(call->hdr,);
+    // bcf_hdr_append(call->hdr,);
+    bcf_hdr_append(call->hdr,"##INFO=<ID=DP4,Number=4,Type=Integer,Description=\"Number of high-quality ref-forward , ref-reverse, alt-forward and alt-reverse bases\">");
+
+    return;
+}
+void ccall_destroy(call_t *call)
+{
+    free(call->itmp);
+    free(call->als_map);
+    free(call->gts);
+    free(call->anno16);
+    free(call->PLs);
+    free(call->GQs);
+    free(call->pdg);
+    bcf_p1_destroy(call->cdat->p1);
+    free(call->cdat);
+    return;
+}
+
+// Inits P(D|G): convert PLs from log space, only two alleles (three PLs) are used.
+// NB: The original samtools calling code uses pdgs in reverse order (AA comes
+// first, RR last), while the -m calling model uses the canonical order.
+static void set_pdg3(double *pl2p, int *PLs, double *pdg, int n_smpl, int n_gt)
+{
+    int i;
+    for (i=0; i<n_smpl; i++)
+    {
+        pdg[2] = pl2p[ PLs[0] ];
+        pdg[1] = pl2p[ PLs[1] ];
+        pdg[0] = pl2p[ PLs[2] ];
+        PLs += n_gt;
+        pdg += 3;
+    }
+}
+
+static double ttest(int n1, int n2, float a[4])
+{
+    extern double kf_betai(double a, double b, double x);
+    double t, v, u1, u2;
+    if (n1 == 0 || n2 == 0 || n1 + n2 < 3) return 1.0;
+    u1 = (double)a[0] / n1; u2 = (double)a[2] / n2;
+    if (u1 <= u2) return 1.;
+    t = (u1 - u2) / sqrt(((a[1] - n1 * u1 * u1) + (a[3] - n2 * u2 * u2)) / (n1 + n2 - 2) * (1./n1 + 1./n2));
+    v = n1 + n2 - 2;
+    return t < 0.? 1. : .5 * kf_betai(.5*v, .5, v/(v+t*t));
+}
+
+static int test16_core(float anno[16], anno16_t *a)
+{
+    extern double kt_fisher_exact(int n11, int n12, int n21, int n22, double *_left, double *_right, double *two);
+    double left, right;
+    int i;
+    a->p[0] = a->p[1] = a->p[2] = a->p[3] = 1.;
+    for (i=0; i<4; i++) a->d[i] = anno[i];
+    a->depth = anno[0] + anno[1] + anno[2] + anno[3];
+    a->is_tested = (anno[0] + anno[1] > 0 && anno[2] + anno[3] > 0);
+    if (a->depth == 0) return -1;
+    a->mq = (int)(sqrt((anno[9] + anno[11]) / a->depth) + .499);
+    kt_fisher_exact(anno[0], anno[1], anno[2], anno[3], &left, &right, &a->p[0]);
+    for (i = 1; i < 4; ++i)
+        a->p[i] = ttest(anno[0] + anno[1], anno[2] + anno[3], anno+4*i);
+    return 0;
+}
+
+int test16(float *anno16, anno16_t *a)
+{
+    a->p[0] = a->p[1] = a->p[2] = a->p[3] = 1.;
+    a->d[0] = a->d[1] = a->d[2] = a->d[3] = 0.;
+    a->mq = a->depth = a->is_tested = 0;
+    return test16_core(anno16, a);
+}
+static int update_bcf1(call_t *call, bcf1_t *rec, const bcf_p1rst_t *pr, double em[10])
+{
+    int has_I16, is_var;
+    float fq, r;
+    anno16_t a;
+    float tmpf[4], tmpi;
+
+    bcf_get_info_float(call->hdr, rec, "I16", &call->anno16, &call->n16);
+
+    has_I16 = test16(call->anno16, &a) >= 0? 1 : 0;
+
+    // print EM
+    if (em[0] >= 0)
+    {
+        tmpf[0] = 1 - em[0];
+        bcf_update_info_float(call->hdr, rec, "AF1", tmpf, 1);
+    }
+    if (em[4] >= 0 && em[4] <= 0.05)
+    {
+        tmpf[0] = em[3]; tmpf[1] = em[2]; tmpf[2] = em[1]; tmpf[3] = em[4];
+        bcf_update_info_float(call->hdr, rec, "G3", tmpf, 3);
+        bcf_update_info_float(call->hdr, rec, "HWE", &tmpf[3], 1);
+    }
+    if (em[5] >= 0 && em[6] >= 0)
+    {
+        tmpf[0] = 1 - em[5]; tmpf[1] = 1 - em[6];
+        bcf_update_info_float(call->hdr, rec, "AF2", tmpf, 2);
+    }
+    if (em[7] >= 0)
+    {
+        tmpf[0] = em[7];
+        bcf_update_info_float(call->hdr, rec, "LRT", tmpf, 1);
+    }
+    if (em[8] >= 0)
+    {
+        tmpf[0] = em[8];
+        bcf_update_info_float(call->hdr, rec, "LRT2", tmpf, 1);
+    }
+
+    bcf_p1aux_t *p1 = call->cdat->p1;
+    if (p1->cons_llr > 0)
+    {
+        tmpi = p1->cons_llr;
+        bcf_update_info_int32(call->hdr, rec, "CLR", &tmpi, 1);
+        // todo: trio calling with -c
+        if (p1->cons_gt > 0)
+        {
+            char tmp[4];
+            tmp[0] = p1->cons_gt&0xff; tmp[1] = p1->cons_gt>>8&0xff; tmp[2] = p1->cons_gt>>16&0xff; tmp[3] = 0;
+            bcf_update_info_string(call->hdr, rec, "UGT", tmp);
+            tmp[0] = p1->cons_gt>>32&0xff; tmp[1] = p1->cons_gt>>40&0xff; tmp[2] = p1->cons_gt>>48&0xff;
+            bcf_update_info_string(call->hdr, rec, "CGT", tmp);
+        }
+    }
+    is_var = (pr->p_ref < call->pref);
+    r = is_var? pr->p_ref : pr->p_var;
+
+    bcf_update_info_int32(call->hdr, rec, "AC1", &pr->ac, 1);
+    int32_t dp[4]; dp[0] = call->anno16[0]; dp[1] = call->anno16[1]; dp[2] = call->anno16[2]; dp[3] = call->anno16[3];
+    bcf_update_info_int32(call->hdr, rec, "DP4", dp, 4);
+    bcf_update_info_int32(call->hdr, rec, "MQ", &a.mq, 1);
+
+    fq = pr->p_ref_folded < 0.5? -4.343 * log(pr->p_ref_folded) : 4.343 * log(pr->p_var_folded);
+    if (fq < -999) fq = -999;
+    if (fq > 999) fq = 999;
+    bcf_update_info_float(call->hdr, rec, "FQ", &fq, 1);
+
+    assert( pr->cmp[0]<0 );
+    // todo
+    //  if (pr->cmp[0] >= 0.) { // two sample groups
+    //      int i, q[3];
+    //      for (i = 1; i < 3; ++i) {
+    //          double x = pr->cmp[i] + pr->cmp[0]/2.;
+    //          q[i] = x == 0? 255 : (int)(-4.343 * log(x) + .499);
+    //          if (q[i] > 255) q[i] = 255;
+    //      }
+    //      if (pr->perm_rank >= 0) ksprintf(&s, "PR=%d;", pr->perm_rank);
+    //
+    //      ksprintf(&s, "PCHI2=%.3g;PC2=%d,%d;", q[1], q[2], pr->p_chi2);
+    //  }
+
+    if (has_I16 && a.is_tested)
+    {
+        int i;
+        for (i=0; i<4; i++) tmpf[i] = a.p[i];
+        bcf_update_info_float(call->hdr, rec, "PV4", tmpf, 4);
+    }
+    bcf_update_info_int32(call->hdr, rec, "I16", NULL, 0);     // remove I16 tag
+    bcf_update_info_int32(call->hdr, rec, "QS", NULL, 0);      // remove QS tag
+
+    rec->qual = r < 1e-100? 999 : -4.343 * log(r);
+    if (rec->qual > 999) rec->qual = 999;
+
+    // Remove unused alleles
+    int nals_ori = rec->n_allele, nals = !is_var && !(call->flag & CALL_KEEPALT) ? 1 : pr->rank0 < 2? 2 : pr->rank0+1;
+    if ( call->flag & CALL_KEEPALT && call->unseen==nals-1 ) nals--;
+    
+    if ( nals<rec->n_allele )
+    {
+        bcf_update_alleles(call->hdr, rec, (const char**)rec->d.allele, nals);
+
+        // Update PLs
+        int npls_src = call->nPLs / rec->n_sample, npls_dst = nals*(nals+1)/2;
+        int *pls_src = call->PLs - npls_src, *pls_dst = call->PLs - npls_dst;
+        int isample, i;
+        for (isample = 0; isample < rec->n_sample; isample++)
+        {
+            pls_src += npls_src;
+            pls_dst += npls_dst;
+            if ( !call->ploidy || call->ploidy[isample]==2 )
+            {
+                for (i=0; i<npls_dst; i++)
+                    pls_dst[i] =  pls_src[i];
+            }
+            else
+            {
+                for (i=0; i<nals; i++)
+                {
+                    int isrc = (i+1)*(i+2)/2-1;
+                    pls_dst[i] = pls_src[isrc];
+                }
+                if (i<npls_dst) pls_dst[i] = bcf_int32_vector_end;
+            }
+        }
+        bcf_update_format_int32(call->hdr, rec, "PL", call->PLs, npls_dst*rec->n_sample);
+    }
+
+    // Call genotypes
+    int i;
+    for (i=0; i<rec->n_sample; i++)
+    {
+        int x = ( is_var || call->output_tags & CALL_FMT_GQ ) ? bcf_p1_call_gt(p1, pr->f_exp, i, is_var) : 2;
+        int gt = x&3;
+        if ( !call->ploidy || call->ploidy[i]==2 )
+        {
+            if ( gt==1 )
+            {
+                call->gts[2*i]   = bcf_gt_unphased(0);
+                call->gts[2*i+1] = bcf_gt_unphased(1);
+            }
+            else if ( gt==0 )
+            {
+                call->gts[2*i]   = bcf_gt_unphased(1);
+                call->gts[2*i+1] = bcf_gt_unphased(1);
+            }
+            else
+            {
+                call->gts[2*i]   = bcf_gt_unphased(0);
+                call->gts[2*i+1] = bcf_gt_unphased(0);
+            }
+            if ( call->output_tags & CALL_FMT_GQ ) call->GQs[i] = x>>2;
+        }
+        else
+        {
+            if ( gt==0 ) call->gts[2*i] = bcf_gt_unphased(1);
+            else call->gts[2*i] = bcf_gt_unphased(0);
+            call->gts[2*i+1] = bcf_int32_vector_end;
+            if ( call->output_tags & CALL_FMT_GQ ) call->GQs[i] = bcf_int32_missing;
+        }
+    }
+    bcf_update_genotypes(call->hdr, rec, call->gts, rec->n_sample*2);
+    if ( call->output_tags & CALL_FMT_GQ )
+        bcf_update_format_int32(call->hdr, rec, "GQ", call->GQs, rec->n_sample);
+
+    // trim Number=R tags
+    int out_als = 0;
+    for (i=0; i<nals; i++) out_als |= 1<<i;
+    init_allele_trimming_maps(call, nals_ori, out_als);
+    mcall_trim_and_update_numberR(call, rec, nals_ori, nals);
+
+    return is_var;
+}
+
+
+int ccall(call_t *call, bcf1_t *rec)
+{
+    int nsmpl = bcf_hdr_nsamples(call->hdr);
+
+    // Get the genotype likelihoods
+    int nals = rec->n_allele;
+    call->nPLs = bcf_get_format_int32(call->hdr, rec, "PL", &call->PLs, &call->mPLs);
+    if ( call->nPLs!=nsmpl*nals*(nals+1)/2 && call->nPLs!=nsmpl*nals )  // diploid+haploid or haploid only
+        error("Wrong number of PL fields? nals=%d npl=%d\n", nals,call->nPLs);
+
+    // Convert PLs to probabilities, only first two alleles are considered
+    int ngts = nals*(nals+1)/2;
+    hts_expand(double, 3*nsmpl, call->npdg, call->pdg);
+    set_pdg3(call->pl2p, call->PLs, call->pdg, nsmpl, ngts);
+
+    double em[10] = {-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.,-1.};
+    int ret = bcf_em1(call, rec, call->ngrp1_samples, 0x1ff, em);
+
+    bcf_p1rst_t pr;
+    int do_contrast = (em[7] >= 0 && em[7] < call->min_lrt) ? 1 : 0;
+    ret = bcf_p1_cal(call, rec, do_contrast, call->cdat->p1, &pr);
+    if (pr.p_ref >= call->pref && (call->flag & CALL_VARONLY)) return 0;
+    if (ret >= 0) ret = update_bcf1(call, rec, &pr, em);
+    return ret;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/bcftools/hclust.h

@@ -0,0 +1,77 @@
+/* The MIT License
+
+   Copyright (c) 2016 Genome Research Ltd.
+
+   Author: Petr Danecek <pd3@sanger.ac.uk>
+   
+   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.
+
+ */
+
+/*
+    Simple hierarchical clustering
+*/
+
+#ifndef __HCLUST_H__
+#define __HCLUST_H__
+
+#include <stdio.h>
+
+typedef struct _hclust_t hclust_t;
+
+typedef struct
+{
+    float dist;
+    int nmemb, *memb;
+}
+cluster_t;
+
+#define PDIST(mat,a,b) (mat)[((a)>(b)?((a)*((a)-1)/2+(b)):((b)*((b)-1)/2+(a)))]
+
+/*
+ *  hclust_init() - init and run clustering
+ *  @n:     number of elements
+ *  @pdist: pairwise distances. The array will be modified by hclust and
+ *          must exist until hclust_destroy() is called
+ */
+hclust_t *hclust_init(int n, float *pdist);
+void hclust_destroy(hclust_t *clust);
+
+/*
+ *  hclust_create_list() - returns a list of clusters
+ *  @min_inter_dist: minimum inter-cluster distance. If smaller, elements are considered
+ *                   homogenous, belonging to the same cluster.
+ *  @max_intra_dist: maximum intra-cluster distance allowed. If smaller than 0,
+ *                   the threshold can be heuristically lowered, otherwise considered
+ *                   a fixed cutoff. The pointer will be filled to the cutoff actually used.
+ */
+cluster_t *hclust_create_list(hclust_t *clust, float min_inter_dist, float *max_intra_dist, int *nclust);
+void hclust_destroy_list(cluster_t *clust, int nclust);
+
+/* 
+ *  Access debugging data used in the decision making process.  Note that this
+ *  must be called immediately after hclust_create_list because other calls,
+ *  such as hclust_create_dot(), invalidate the temporary data structures.
+ */
+char **hclust_explain(hclust_t *clust, int *nlines);
+
+char *hclust_create_dot(hclust_t *clust, char **labels, float th);
+
+#endif
+

falcon/lib/python3.10/site-packages/pysam/include/bcftools/ploidy.c

@@ -0,0 +1,268 @@
+/* 
+    Copyright (C) 2014-2016 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+    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.
+*/
+
+#include <htslib/khash_str2int.h>
+#include <htslib/kseq.h>
+#include <htslib/hts.h>
+#include "bcftools.h"
+#include "ploidy.h"
+
+struct _ploidy_t
+{
+    int nsex, msex;     // number of genders, m:number of allocated elements in id2sex array
+    int dflt, min, max; // ploidy: default, min and max (only explicitly listed)
+    int *sex2dflt;
+    regidx_t *idx;
+    regitr_t *itr;
+    void *sex2id;
+    char **id2sex;
+    kstring_t tmp_str;
+};
+
+typedef struct
+{
+    int sex, ploidy;
+}
+sex_ploidy_t;
+
+
+regidx_t *ploidy_regions(ploidy_t *ploidy)
+{
+    return ploidy->idx;
+}
+
+int ploidy_parse(const char *line, char **chr_beg, char **chr_end, uint32_t *beg, uint32_t *end, void *payload, void *usr)
+{
+    int i, ret;
+    ploidy_t *ploidy = (ploidy_t*) usr;
+    void *sex2id = ploidy->sex2id;
+
+    // Check for special case of default ploidy "* * * <sex> <ploidy>"
+    int default_ploidy_def = 0;
+
+    char *ss = (char*) line;
+    while ( *ss && isspace(*ss) ) ss++;
+    if ( ss[0]=='*' && (!ss[1] || isspace(ss[1])) )
+        default_ploidy_def = 1; // definition of default ploidy, chr="*"
+    else
+    {
+        // Fill CHR,FROM,TO
+        ret = regidx_parse_tab(line,chr_beg,chr_end,beg,end,NULL,NULL);
+        if ( ret!=0 ) return ret;
+    }
+
+    // Skip the fields already parsed by regidx_parse_tab
+    ss = (char*) line;
+    while ( *ss && isspace(*ss) ) ss++;
+    for (i=0; i<3; i++)
+    {
+        while ( *ss && !isspace(*ss) ) ss++;
+        if ( !*ss ) return -2;  // wrong number of fields
+        while ( *ss && isspace(*ss) ) ss++;
+    }
+    if ( !*ss ) return -2;
+
+    // Parse the payload
+    char *se = ss;
+    while ( *se && !isspace(*se) ) se++;
+    if ( !*se || se==ss ) error("Could not parse: %s\n", line);
+    ploidy->tmp_str.l = 0;
+    kputsn(ss,se-ss,&ploidy->tmp_str);
+
+    sex_ploidy_t *sp = (sex_ploidy_t*) payload;
+    if ( khash_str2int_get(sex2id, ploidy->tmp_str.s, &sp->sex) != 0 )
+    {
+        ploidy->nsex++;
+        hts_expand0(char*,ploidy->nsex,ploidy->msex,ploidy->id2sex);
+        ploidy->id2sex[ploidy->nsex-1] = strdup(ploidy->tmp_str.s);
+        sp->sex = khash_str2int_inc(ploidy->sex2id, ploidy->id2sex[ploidy->nsex-1]);
+        ploidy->sex2dflt = (int*) realloc(ploidy->sex2dflt,sizeof(int)*ploidy->nsex);
+        ploidy->sex2dflt[ploidy->nsex-1] = -1;
+    }
+
+    ss = se;
+    while ( *se && isspace(*se) ) se++;
+    if ( !*se ) error("Could not parse: %s\n", line);
+    sp->ploidy = strtol(ss,&se,10);
+    if ( ss==se ) error("Could not parse: %s\n", line);
+    if ( ploidy->min<0 || sp->ploidy < ploidy->min ) ploidy->min = sp->ploidy;
+    if ( ploidy->max<0 || sp->ploidy > ploidy->max ) ploidy->max = sp->ploidy;
+
+    // Special case, chr="*" stands for a default value
+    if ( default_ploidy_def )
+    {
+        ploidy->sex2dflt[ploidy->nsex-1] = sp->ploidy;
+        return -1;
+    }
+
+    return 0;
+}
+
+static void _set_defaults(ploidy_t *ploidy, int dflt)
+{
+    int i;
+    if ( khash_str2int_get(ploidy->sex2id, "*", &i) == 0 ) dflt = ploidy->sex2dflt[i];
+    for (i=0; i<ploidy->nsex; i++)
+        if ( ploidy->sex2dflt[i]==-1 ) ploidy->sex2dflt[i] = dflt;
+
+    ploidy->dflt = dflt;
+    if ( ploidy->min<0 || dflt < ploidy->min ) ploidy->min = dflt;
+    if ( ploidy->max<0 || dflt > ploidy->max ) ploidy->max = dflt;
+}
+
+ploidy_t *ploidy_init(const char *fname, int dflt)
+{
+    ploidy_t *pld = (ploidy_t*) calloc(1,sizeof(ploidy_t));
+    if ( !pld ) return NULL;
+
+    pld->min = pld->max = -1;
+    pld->sex2id = khash_str2int_init();
+    pld->idx = regidx_init(fname,ploidy_parse,NULL,sizeof(sex_ploidy_t),pld);
+    if ( !pld->idx )
+    {
+        ploidy_destroy(pld);
+        return NULL;
+    }
+    pld->itr = regitr_init(pld->idx);
+    _set_defaults(pld,dflt);
+    return pld;
+}
+
+ploidy_t *ploidy_init_string(const char *str, int dflt)
+{
+    ploidy_t *pld = (ploidy_t*) calloc(1,sizeof(ploidy_t));
+    if ( !pld ) return NULL;
+
+    pld->min = pld->max = -1;
+    pld->sex2id = khash_str2int_init();
+    pld->idx = regidx_init(NULL,ploidy_parse,NULL,sizeof(sex_ploidy_t),pld);
+    pld->itr = regitr_init(pld->idx);
+
+    kstring_t tmp = {0,0,0};
+    const char *ss = str;
+    while ( *ss )
+    {
+        while ( *ss && isspace(*ss) ) ss++;
+        const char *se = ss;
+        while ( *se && *se!='\r' && *se!='\n' ) se++;
+        tmp.l = 0;
+        kputsn(ss, se-ss, &tmp);
+        regidx_insert(pld->idx,tmp.s);
+        while ( *se && isspace(*se) ) se++;
+        ss = se;
+    }
+    free(tmp.s);
+
+    _set_defaults(pld,dflt);
+    return pld;
+}
+
+void ploidy_destroy(ploidy_t *ploidy)
+{
+    if ( ploidy->sex2id ) khash_str2int_destroy_free(ploidy->sex2id);
+    if ( ploidy->itr ) regitr_destroy(ploidy->itr);
+    if ( ploidy->idx ) regidx_destroy(ploidy->idx);
+    free(ploidy->id2sex);
+    free(ploidy->tmp_str.s);
+    free(ploidy->sex2dflt);
+    free(ploidy);
+}
+
+int ploidy_query(ploidy_t *ploidy, char *seq, int pos, int *sex2ploidy, int *min, int *max)
+{
+    int i, ret = regidx_overlap(ploidy->idx, seq,pos,pos, ploidy->itr);
+
+    if ( !sex2ploidy && !min && !max ) return ret;
+
+    if ( !ret )
+    {
+        // no overlap
+        if ( min ) *min = ploidy->dflt;
+        if ( max ) *max = ploidy->dflt;
+        if ( sex2ploidy )
+            for (i=0; i<ploidy->nsex; i++) sex2ploidy[i] = ploidy->sex2dflt[i];
+        return 0;
+    }
+
+    int _min = INT_MAX, _max = -1;
+    if ( sex2ploidy ) for (i=0; i<ploidy->nsex; i++) sex2ploidy[i] = ploidy->dflt;
+
+    while ( regitr_overlap(ploidy->itr) )
+    {
+        int sex = regitr_payload(ploidy->itr,sex_ploidy_t).sex;
+        int pld = regitr_payload(ploidy->itr,sex_ploidy_t).ploidy;
+        if ( pld!=ploidy->dflt ) 
+        {
+            if ( sex2ploidy ) sex2ploidy[ sex ] = pld;
+            if ( _min > pld ) _min = pld;
+            if ( _max < pld ) _max = pld;
+        }
+    }
+    if ( _max==-1 ) _max = _min = ploidy->dflt;
+    if ( max ) *max = _max;
+    if ( min ) *min = _min;
+
+    return 1;
+}
+
+int ploidy_nsex(ploidy_t *ploidy)
+{
+    return ploidy->nsex;
+}
+
+char *ploidy_id2sex(ploidy_t *ploidy, int id)
+{
+    if ( id<0 || id>=ploidy->nsex ) return NULL;
+    return ploidy->id2sex[id];
+}
+
+int ploidy_sex2id(ploidy_t *ploidy, char *sex)
+{
+    int id;
+    if ( khash_str2int_get(ploidy->sex2id,sex,&id)!=0 ) return -1;
+    return id;
+}
+
+int ploidy_add_sex(ploidy_t *ploidy, const char *sex)
+{
+    int id;
+    if ( khash_str2int_get(ploidy->sex2id, sex, &id)==0 ) return id;
+    ploidy->nsex++;
+    hts_expand0(char*,ploidy->nsex,ploidy->msex,ploidy->id2sex);
+    ploidy->id2sex[ploidy->nsex-1] = strdup(sex);
+    ploidy->sex2dflt = (int*) realloc(ploidy->sex2dflt,sizeof(int)*ploidy->nsex);
+    ploidy->sex2dflt[ploidy->nsex-1] = ploidy->dflt;
+    return khash_str2int_inc(ploidy->sex2id, ploidy->id2sex[ploidy->nsex-1]);
+}
+
+int ploidy_max(ploidy_t *ploidy)
+{
+    return ploidy->dflt > ploidy->max ? ploidy->dflt : ploidy->max;
+}
+
+int ploidy_min(ploidy_t *ploidy)
+{
+    return ploidy->dflt < ploidy->min ? ploidy->dflt : ploidy->min;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/bcftools/rbuf.h

@@ -0,0 +1,261 @@
+/*  rbuf.h -- round buffers.
+
+    Copyright (C) 2013-2014, 2017 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#ifndef __RBUF_H__
+#define __RBUF_H__
+
+#include <string.h>
+
+typedef struct
+{
+    int m,n,f;    // m: allocated size, n: number of elements in the buffer, f: first element
+}
+rbuf_t;
+
+/**
+ *  rbuf_init() - initialize round buffer
+ *  @rbuf:  the rbuf_t holder
+ *  @size:  the maximum number of elements
+ *
+ */
+static inline void rbuf_init(rbuf_t *rbuf, int size)
+{
+    rbuf->m = size; rbuf->n = rbuf->f = 0;
+}
+/**
+ *  rbuf_kth() - get index of the k-th element of the round buffer
+ *  @rbuf:  the rbuf_t holder
+ *  @k:     0-based index. If negative, return k-th element from the end, 1-based
+ */
+static inline int rbuf_kth(rbuf_t *rbuf, int k)
+{
+    if ( k >= rbuf->n ) return -1;
+    if ( k < 0 )
+    {
+        k = rbuf->n + k; 
+        if ( k < 0 ) return -1;
+    }
+    int i = k + rbuf->f;
+    if ( i >= rbuf->m ) i -= rbuf->m;
+    return i;
+}
+/**
+ *  rbuf_last() - get index of the last element of the round buffer
+ *  @rbuf:  the rbuf_t holder
+ */
+#define rbuf_last(rbuf) rbuf_kth(rbuf, -1)
+
+/**
+ *  rbuf_l2ridx() - get 0-based rbuf index which corresponds to i-th linear index
+ *  @rbuf:  the rbuf_t holder
+ *  @idx:   0-based linear index
+ *
+ *  Returns 0-based circular index or -1 if out of bounds
+ */
+static inline int rbuf_l2ridx(rbuf_t *rbuf, int idx)
+{
+    if ( idx < 0 || idx >= rbuf->n ) return -1;
+    if ( idx >= rbuf->f )
+    {
+        int i = idx - rbuf->f;
+        if ( i >= rbuf->n ) return -1;
+        return i;
+    }
+    int i = rbuf->m - rbuf->f + idx;
+    if ( i >= rbuf->n ) return -1;
+    return i;
+}
+
+/**
+ *  rbuf_next() - get index of the next element in the round buffer
+ *  @rbuf:  the rbuf_t holder
+ *  @i:     pointer to the last rbuf index. Set to -1 before the first call.
+ *
+ *  Sets i to the next position in the buffer. The return value indicates if
+ *  the position points to a valid element (1) or if there are no more elements
+ *  after *i (0). When the end is reached, *i is set to the first element in the
+ *  buffer.
+ */
+static inline int rbuf_next(rbuf_t *rbuf, int *i)
+{
+    if ( !rbuf->n ) return 0;
+    if ( *i==-1 ) { *i = rbuf->f; return 1; }
+    int n = (rbuf->f <= *i) ? *i - rbuf->f + 1 : *i + rbuf->m - rbuf->f + 1;
+    if ( ++(*i) >= rbuf->m ) *i = 0;
+    if ( n < rbuf->n ) return 1;
+    *i = rbuf->f;
+    return 0;
+}
+/**
+ *  rbuf_prev() - get index of the previous element in the round buffer
+ *  @rbuf:  the rbuf_t holder
+ *  @i:     pointer to the last rbuf index. Set to -1 before the first call.
+ *
+ *  Sets i to the previous position in the buffer. The return value indicates if
+ *  the position points to a valid element (1) or if there are no more elements
+ *  before *i (0).
+ */
+static inline int rbuf_prev(rbuf_t *rbuf, int *i)
+{
+    if ( !rbuf->n || *i==rbuf->f ) return 0;
+    if ( *i==-1 )
+    {
+        *i = rbuf_last(rbuf);
+        return 1;
+    }
+    if ( --(*i) < 0 ) *i = rbuf->m - 1;
+    return 1;
+}
+/**
+ *  rbuf_prepend() - register new element at the start of the round buffer
+ *  @rbuf:  the rbuf_t holder
+ *
+ *  Returns index of the newly inserted element.
+ */
+static inline int rbuf_prepend(rbuf_t *rbuf)
+{
+    if ( rbuf->n < rbuf->m ) rbuf->n++;
+
+    rbuf->f = rbuf->f > 0 ? rbuf->f - 1 : rbuf->m - 1;
+    return rbuf->f;
+}
+/**
+ *  rbuf_append() - register new element at the end of the round buffer
+ *  @rbuf:  the rbuf_t holder
+ *
+ *  Returns index of the newly inserted element.
+ */
+static inline int rbuf_append(rbuf_t *rbuf)
+{
+    if ( rbuf->n < rbuf->m )
+    {
+        rbuf->n++;
+        int i = rbuf->f + rbuf->n;
+        return i <= rbuf->m ? i - 1 : i - rbuf->m - 1;
+    }
+
+    rbuf->f++;
+    if ( rbuf->f >= rbuf->m )
+    {
+        rbuf->f = 0;
+        return rbuf->m - 1;
+    }
+    return rbuf->f - 1;
+}
+/**
+ *  rbuf_shift() - removes first element from the buffer
+ *  @rbuf:  the rbuf_t holder
+ *
+ *  Returns index of the removed element.
+ */
+static inline int rbuf_shift(rbuf_t *rbuf)
+{
+    if ( !rbuf->n ) return -1;
+    int ret = rbuf->f;
+    rbuf->f++;
+    if ( rbuf->f >= rbuf->m ) rbuf->f = 0;
+    rbuf->n--;
+    return ret;
+}
+/**
+ *  rbuf_shift_n() - removes first n elements from the buffer
+ *  @rbuf:  the rbuf_t holder
+ *  @n:     number of elements to remove
+ */
+static inline void rbuf_shift_n(rbuf_t *rbuf, int n)
+{
+    if ( n >= rbuf->n )
+    {
+        rbuf->n = rbuf->f = 0;
+        return;
+    }
+    rbuf->n -= n;
+    rbuf->f += n;
+    if ( rbuf->f >= rbuf->m ) rbuf->f -= rbuf->m;
+}
+
+/**
+ *  rbuf_expand0() - expand round buffer and set the newly allocated elements to 0
+ *  @rbuf:      the rbuf holder
+ *  @type_t:    data type
+ *  @n:         requested number of elements
+ *  @data:      data array to be realloced
+ *
+ *  Note: The new array is linearized and leaves the rbuf.f offset untouched,
+ *  thus the size of the new buffer is determined by the current position.
+ */
+#define rbuf_expand0(rbuf,type_t,n,data) \
+{ \
+    if ( n > (rbuf)->m ) \
+    { \
+        int m = n + (rbuf)->f; \
+        m--, m|=m>>1, m|=m>>2, m|=m>>4, m|=m>>8, m|=m>>16, m++; /* kroundup32 */ \
+        data = (type_t*) realloc(data, sizeof(type_t)*m); \
+        type_t *ptr = data; \
+        memset(ptr+(rbuf)->m,0,sizeof(type_t)*(m-(rbuf)->m)); \
+        if ( (rbuf)->f ) \
+        { \
+            memcpy(ptr+(rbuf)->m,ptr,sizeof(type_t)*(rbuf)->f); \
+            memset(ptr,0,sizeof(type_t)*(rbuf)->f); \
+        } \
+        (rbuf)->m = m; \
+    } \
+}
+
+/**
+ *  rbuf_remove_kth() - remove k-th rbuf element (0-based) and memmove the data block
+ *  @rbuf:      the rbuf holder
+ *  @type_t:    data type
+ *  @k:         k-th element to remove
+ *  @data:      data array to be modified
+ */
+#define rbuf_remove_kth(rbuf, type_t, kth, data) \
+{ \
+    int k = rbuf_kth(rbuf, kth); \
+    if ( k < (rbuf)->f )    /* shrink from back */ \
+    { \
+        int l = rbuf_kth(rbuf, -1); \
+        if ( k < l ) \
+        { \
+            type_t tmp = (data)[k]; \
+            memmove(data+k, data+k+1, (l - k)*sizeof(type_t)); \
+            (data)[l] = tmp; \
+        } \
+        (rbuf)->n--; \
+    } \
+    else                    /* shrink from front */ \
+    { \
+        if ( k > (rbuf)->f ) \
+        { \
+            type_t tmp = (data)[k]; \
+            memmove(&data[(rbuf)->f+1], &data[(rbuf)->f], (k - (rbuf)->f)*sizeof(type_t)); \
+            (data)[(rbuf)->f] = tmp; \
+        } \
+        (rbuf)->f++; \
+        (rbuf)->n--; \
+        if ( (rbuf)->f == (rbuf)->m ) (rbuf)->f = 0; \
+    } \
+}
+
+#endif

falcon/lib/python3.10/site-packages/pysam/include/bcftools/tsv2vcf.c.pysam.c

@@ -0,0 +1,137 @@
+#include "bcftools.pysam.h"
+
+/*  tsv2vcf.c -- convert from whitespace-separated fields to VCF
+
+    Copyright (C) 2014-2021 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+    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.
+*/
+
+#include <ctype.h>
+#include <strings.h>
+#include "tsv2vcf.h"
+
+tsv_t *tsv_init(const char *str)
+{
+    tsv_t *tsv = (tsv_t *) calloc(1,sizeof(tsv_t));
+    kstring_t tmp = {0,0,0};
+    const char *ss = str, *se = ss;
+    tsv->ncols = 0;
+    while ( *ss )
+    {
+        if ( *se && *se!=',' ) { se++; continue; }
+        tsv->ncols++;
+        tsv->cols = (tsv_col_t*) realloc(tsv->cols,sizeof(tsv_col_t)*tsv->ncols);
+        tsv->cols[tsv->ncols-1].name   = NULL;
+        tsv->cols[tsv->ncols-1].setter = NULL;
+        tmp.l = 0;
+        kputsn(ss, se-ss, &tmp);
+        if ( strcasecmp("-",tmp.s) )
+            tsv->cols[tsv->ncols-1].name = strdup(tmp.s);
+        if ( !*se ) break;
+        ss = ++se;
+    }
+    free(tmp.s);
+    return tsv;
+}
+
+void tsv_destroy(tsv_t *tsv)
+{
+    int i;
+    for (i=0; i<tsv->ncols; i++) free(tsv->cols[i].name);
+    free(tsv->cols);
+    free(tsv);
+}
+
+int tsv_register(tsv_t *tsv, const char *id, tsv_setter_t setter, void *usr)
+{
+    int i;
+    for (i=0; i<tsv->ncols; i++)
+    {
+        if ( !tsv->cols[i].name || strcasecmp(tsv->cols[i].name,id) ) continue;
+        tsv->cols[i].setter = setter;
+        tsv->cols[i].usr    = usr;
+        return 0;
+    }
+    return -1;
+}
+
+int tsv_parse(tsv_t *tsv, bcf1_t *rec, char *str)
+{
+    int status = 0;
+    tsv->icol = 0;
+    tsv->ss = tsv->se = str;
+    while ( *tsv->ss && tsv->icol < tsv->ncols )
+    {
+        while ( *tsv->se && !isspace(*tsv->se) ) tsv->se++;
+        if ( tsv->cols[tsv->icol].setter )
+        {
+            int ret = tsv->cols[tsv->icol].setter(tsv,rec,tsv->cols[tsv->icol].usr);
+            if ( ret<0 ) return -1;
+            status++;
+        }
+        while ( *tsv->se && isspace(*tsv->se) ) tsv->se++;
+        tsv->ss = tsv->se;
+        tsv->icol++;
+    }
+    return status ? 0 : -1;
+}
+
+int tsv_setter_chrom(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    char tmp = *tsv->se;
+    *tsv->se = 0;
+    rec->rid = bcf_hdr_name2id((bcf_hdr_t*)usr, tsv->ss);
+    *tsv->se = tmp;
+    return rec->rid==-1 ? -1 : 0;
+}
+
+int tsv_setter_pos(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    char *endptr;
+    rec->pos = strtol(tsv->ss, &endptr, 10) - 1;
+    if ( tsv->ss==endptr ) return -1;
+    return 0;
+}
+
+int tsv_setter_id(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    char tmp = *tsv->se;
+    *tsv->se = 0;
+    bcf_update_id((bcf_hdr_t*)usr, rec, tsv->ss);
+    *tsv->se = tmp;
+    return 0;
+}
+
+int tsv_setter_ref_alt(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    bcf_hdr_t *hdr = (bcf_hdr_t*)usr;
+    char *sb = tsv->ss;
+    while ( *sb && !isspace(*sb) ) sb++;
+    if ( !*sb ) return -1;
+    char tmp = *sb;
+    *sb = ',';
+    bcf_update_alleles_str(hdr, rec, tsv->ss);
+    *sb = tmp;
+    return 0;
+}
+
+

falcon/lib/python3.10/site-packages/pysam/include/bcftools/vcfconvert.c

@@ -0,0 +1,1791 @@
+/*  vcfconvert.c -- convert between VCF/BCF and related formats.
+
+    Copyright (C) 2013-2023 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#include <stdio.h>
+#include <strings.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <ctype.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <inttypes.h>
+#include <htslib/faidx.h>
+#include <htslib/vcf.h>
+#include <htslib/bgzf.h>
+#include <htslib/synced_bcf_reader.h>
+#include <htslib/vcfutils.h>
+#include <htslib/kseq.h>
+#include "bcftools.h"
+#include "filter.h"
+#include "convert.h"
+#include "tsv2vcf.h"
+
+// Logic of the filters: include or exclude sites which match the filters?
+#define FLT_INCLUDE 1
+#define FLT_EXCLUDE 2
+
+typedef struct _args_t args_t;
+struct _args_t
+{
+    faidx_t *ref;
+    filter_t *filter;
+    char *filter_str;
+    int filter_logic;   // include or exclude sites which match the filters? One of FLT_INCLUDE/FLT_EXCLUDE
+    convert_t *convert;
+    bcf_srs_t *files;
+    bcf_hdr_t *header;
+    void (*convert_func)(struct _args_t *);
+    struct {
+        int total, skipped, hom_rr, het_ra, hom_aa, het_aa, missing, written;
+    } n;
+    kstring_t str;
+    int32_t *gts;
+    float *flt;
+    int rev_als, output_vcf_ids, hap2dip, gen_3N6;
+    int nsamples, *samples, sample_is_file, targets_is_file, regions_is_file, output_type;
+    int regions_overlap, targets_overlap;
+    char **argv, *sample_list, *targets_list, *regions_list, *tag, *columns;
+    char *outfname, *infname, *ref_fname, *sex_fname;
+    int argc, n_threads, record_cmd_line, keep_duplicates, clevel;
+    char *index_fn;
+    int write_index;
+    struct {
+        kstring_t ref,alt,refalt;
+    } tsv;
+};
+
+static void destroy_data(args_t *args)
+{
+    if ( args->ref ) fai_destroy(args->ref);
+    if ( args->convert) convert_destroy(args->convert);
+    if ( args->filter ) filter_destroy(args->filter);
+    free(args->samples);
+    if ( args->files ) bcf_sr_destroy(args->files);
+}
+
+static void open_vcf(args_t *args, const char *format_str)
+{
+    args->files = bcf_sr_init();
+    if ( args->n_threads && bcf_sr_set_threads(args->files, args->n_threads)!=0 )
+        error("Could not initialize --threads %d\n", args->n_threads);
+
+    if ( args->regions_list )
+    {
+        bcf_sr_set_opt(args->files,BCF_SR_REGIONS_OVERLAP,args->regions_overlap);
+        if ( bcf_sr_set_regions(args->files, args->regions_list, args->regions_is_file)<0 )
+            error("Failed to read the regions: %s\n", args->regions_list);
+    }
+    if ( args->targets_list )
+    {
+        bcf_sr_set_opt(args->files,BCF_SR_TARGETS_OVERLAP,args->targets_overlap);
+        if ( bcf_sr_set_targets(args->files, args->targets_list, args->targets_is_file, 0)<0 )
+            error("Failed to read the targets: %s\n", args->targets_list);
+    }
+    if ( !bcf_sr_add_reader(args->files, args->infname) )
+        error("Failed to open %s: %s\n", args->infname,bcf_sr_strerror(args->files->errnum));
+
+    args->header = args->files->readers[0].header;
+
+    if ( args->filter_str )
+        args->filter = filter_init(args->header, args->filter_str);
+
+    int i, nsamples = 0, *samples = NULL;
+    if ( args->sample_list && strcmp("-",args->sample_list) )
+    {
+        for (i=0; i<args->files->nreaders; i++)
+        {
+            int ret = bcf_hdr_set_samples(args->files->readers[i].header,args->sample_list,args->sample_is_file);
+            if ( ret<0 ) error("Error parsing the sample list\n");
+            else if ( ret>0 ) error("Sample name mismatch: sample #%d not found in the header\n", ret);
+        }
+
+        if ( args->sample_list[0]!='^' )
+        {
+            // the sample ordering may be different if not negated
+            int n;
+            char **smpls = hts_readlist(args->sample_list, args->sample_is_file, &n);
+            if ( !smpls ) error("Could not parse %s\n", args->sample_list);
+            if ( n!=bcf_hdr_nsamples(args->files->readers[0].header) )
+                error("The number of samples does not match, perhaps some are present multiple times?\n");
+            nsamples = bcf_hdr_nsamples(args->files->readers[0].header);
+            samples = (int*) malloc(sizeof(int)*nsamples);
+            for (i=0; i<n; i++)
+            {
+                samples[i] = bcf_hdr_id2int(args->files->readers[0].header, BCF_DT_SAMPLE,smpls[i]);
+                free(smpls[i]);
+            }
+            free(smpls);
+        }
+    }
+    if ( format_str ) args->convert = convert_init(args->header, samples, nsamples, format_str);
+    free(samples);
+}
+
+static int _set_ref_alt(args_t *args, bcf1_t *rec)
+{
+    args->tsv.refalt.l = 0;
+    kputs(args->tsv.ref.s, &args->tsv.refalt);
+    if ( strcmp(".",args->tsv.alt.s) && strcmp(args->tsv.ref.s,args->tsv.alt.s) )
+    {
+        kputc(',', &args->tsv.refalt);
+        kputs(args->tsv.alt.s, &args->tsv.refalt);
+    }
+    bcf_update_alleles_str(args->header, rec, args->tsv.refalt.s);
+    args->tsv.ref.l = 0;
+    args->tsv.alt.l = 0;
+    args->tsv.refalt.l = 0;
+    return 0;
+}
+static int tsv_setter_ref(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+    kputsn(tsv->ss,tsv->se - tsv->ss,&args->tsv.ref);
+    if ( args->tsv.alt.l ) return _set_ref_alt(args,rec);
+    return 0;
+}
+static int tsv_setter_alt(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+    kputsn(tsv->ss,tsv->se - tsv->ss,&args->tsv.alt);
+    if ( args->tsv.ref.l ) return _set_ref_alt(args,rec);
+    return 0;
+}
+
+// Try to set CHROM:POS_REF_ALT[_END]. Return 0 on success, -1 on error
+static int _set_chrom_pos_ref_alt(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+
+    char tmp, *se = tsv->ss, *ss = tsv->ss;
+    while ( se < tsv->se && *se!=':' ) se++;
+    if ( *se!=':' ) return -1;
+    tmp = *se; *se = 0;
+    int rid = bcf_hdr_name2id(args->header,ss);
+    *se = tmp;
+    if ( rid<0 ) return -1;
+
+    // POS
+    hts_pos_t pos = strtol(se+1,&ss,10);
+    if ( ss==se+1 ) return -1;
+    pos--;
+
+    // REF,ALT
+    args->str.l = 0;
+    se = ++ss;
+    while ( se < tsv->se && *se!='_' ) se++;
+    if ( *se!='_' ) return -1;
+    kputsn(ss,se-ss,&args->str);
+    ss = ++se;
+    while ( se < tsv->se && *se!='_' && isspace(*tsv->se) ) se++;
+    if ( se < tsv->se && *se!='_' && isspace(*tsv->se) ) return -1;
+    kputc(',',&args->str);
+    kputsn(ss,se-ss,&args->str);
+
+    // END - optional
+    if (*se && *se=='_')
+    {
+        long end = strtol(se+1,&ss,10);
+        if ( ss==se+1 ) return -1;
+        bcf_update_info_int32(args->header, rec, "END", &end, 1);
+    }
+
+    rec->rid = rid;
+    rec->pos = pos;
+    bcf_update_alleles_str(args->header, rec, args->str.s);
+
+    return 0;
+}
+static int tsv_setter_chrom_pos_ref_alt_or_chrom(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*)usr;
+    int ret = _set_chrom_pos_ref_alt(tsv,rec,usr);
+    if ( !ret ) return ret;
+    return tsv_setter_chrom(tsv,rec,args->header);
+}
+static int tsv_setter_chrom_pos_ref_alt(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    int ret = _set_chrom_pos_ref_alt(tsv,rec,usr);
+    if ( ret!=0 ) error("Could not parse the CHROM:POS_REF_ALT[_END] string: %s\n", tsv->ss);
+    return ret;
+}
+// This function must be called first, then tsv_setter_chrom_pos_ref_alt_id_or_die.
+// One of them is expected to find the CHROM:POS_REF_ALT[_END] string, if not, die.
+static int tsv_setter_chrom_pos_ref_alt_or_id(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*)usr;
+    if ( _set_chrom_pos_ref_alt(tsv,rec,usr)==0 )  return 0;
+    rec->pos = -1;  // mark the record as unset
+    if ( !args->output_vcf_ids) return 0;
+    return tsv_setter_id(tsv,rec,usr);
+}
+static int tsv_setter_chrom_pos_ref_alt_id_or_die(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*)usr;
+    if ( rec->pos!=-1 )
+    {
+        if ( !args->output_vcf_ids ) return 0;
+        return tsv_setter_id(tsv,rec,usr);
+    }
+    return tsv_setter_chrom_pos_ref_alt(tsv,rec,usr);
+}
+static int tsv_setter_verify_pos(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    char *se;
+    int pos = strtol(tsv->ss,&se,10);
+    if ( tsv->ss==se ) error("Could not parse POS: %s\n", tsv->ss);
+    if ( rec->pos != pos-1 ) error("POS mismatch: %s\n", tsv->ss);
+    return 0;
+}
+static int tsv_setter_verify_ref_alt(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+    args->rev_als = 0;
+    char tmp = *tsv->se; *tsv->se = 0;
+    if ( strcmp(tsv->ss,rec->d.allele[0]) )
+    {
+        if ( strcmp(tsv->ss,rec->d.allele[1]) ) { *tsv->se = tmp; error("REF/ALT mismatch: [%s][%s]\n", tsv->ss,rec->d.allele[1]); }
+        args->rev_als = 1;
+    }
+    *tsv->se = tmp;
+    while ( *tsv->se && isspace(*tsv->se) ) tsv->se++;
+    tsv->ss = tsv->se;
+    while ( *tsv->se && !isspace(*tsv->se) ) tsv->se++;
+    tmp = *tsv->se; *tsv->se = 0;
+    if ( !args->rev_als && strcmp(tsv->ss,rec->d.allele[1]) ) { *tsv->se = tmp; error("REF/ALT mismatch: [%s][%s]\n", tsv->ss,rec->d.allele[1]); }
+    else if ( args->rev_als && strcmp(tsv->ss,rec->d.allele[0]) ) { *tsv->se = tmp; error("REF/ALT mismatch: [%s][%s]\n", tsv->ss,rec->d.allele[0]); }
+    *tsv->se = tmp;
+    return 0;
+}
+static int tsv_setter_gt_gp(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+    int i, nsamples = bcf_hdr_nsamples(args->header);
+    for (i=0; i<nsamples; i++)
+    {
+        float aa,ab,bb;
+        aa = strtod(tsv->ss, &tsv->se);
+        if ( tsv->ss==tsv->se ) { fprintf(stderr,"Could not parse first value of %d-th sample\n", i+1); return -1; }
+        tsv->ss = tsv->se+1;
+        ab = strtod(tsv->ss, &tsv->se);
+        if ( tsv->ss==tsv->se ) { fprintf(stderr,"Could not parse second value of %d-th sample\n", i+1); return -1; }
+        tsv->ss = tsv->se+1;
+        bb = strtod(tsv->ss, &tsv->se);
+        if ( tsv->ss==tsv->se ) { fprintf(stderr,"Could not parse third value of %d-th sample\n", i+1); return -1; }
+        tsv->ss = tsv->se+1;
+
+        if ( args->rev_als ) { float tmp = bb; bb = aa; aa = tmp; }
+        args->flt[3*i+0] = aa;
+        args->flt[3*i+1] = ab;
+        args->flt[3*i+2] = bb;
+
+        if ( aa >= ab )
+        {
+            if ( aa >= bb ) args->gts[2*i+0] = args->gts[2*i+1] = bcf_gt_unphased(0);
+            else args->gts[2*i+0] = args->gts[2*i+1] = bcf_gt_unphased(1);
+        }
+        else if ( ab >= bb )
+        {
+            args->gts[2*i+0] = bcf_gt_unphased(0);
+            args->gts[2*i+1] = bcf_gt_unphased(1);
+        }
+        else args->gts[2*i+0] = args->gts[2*i+1] = bcf_gt_unphased(1);
+    }
+    if ( *tsv->se ) error("Could not parse: %s\n", tsv->ss);
+    if ( bcf_update_genotypes(args->header,rec,args->gts,nsamples*2) ) error("Could not update GT field\n");
+    if ( bcf_update_format_float(args->header,rec,"GP",args->flt,nsamples*3) ) error("Could not update GP field\n");
+    return 0;
+}
+static int tsv_setter_haps(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+    int i, nsamples = bcf_hdr_nsamples(args->header);
+
+    int32_t a0, a1;
+    if ( args->rev_als ) { a0 = bcf_gt_phased(1); a1 = bcf_gt_phased(0); }
+    else { a0 = bcf_gt_phased(0); a1 = bcf_gt_phased(1); }
+
+    // up is short for "unphased"
+    int nup = 0;
+    for (i=0; i<nsamples; i++)
+    {
+        char *ss = tsv->ss + 4*i + nup;
+        int up = 0, all;
+
+        for (all=0; all < 2; all++){
+            // checking for premature ending
+            if ( !ss[0] || !ss[1] || !ss[2] ||
+                 (up && (!ss[3] || !ss[4]) ) )
+            {
+                fprintf(stderr,"Wrong number of fields at %d-th sample ([%c][%c][%c]). ",i+1,ss[0],ss[1],ss[2]);
+                return -1;
+            }
+
+            switch(ss[all*2+up]){
+            case '0':
+                args->gts[2*i+all] = a0;
+                break;
+            case '1' :
+                args->gts[2*i+all] = a1;
+                break;
+            case '?' :
+                // there is no macro to express phased missing allele
+                args->gts[2*i+all] = bcf_gt_phased(-1);
+                break;
+            case '-' :
+                args->gts[2*i+all] = bcf_int32_vector_end;
+                break;
+            default :
+                fprintf(stderr,"Could not parse: [%c][%s]\n", ss[all*2+up],tsv->ss);
+                return -1;
+            }
+            if( ss[all*2+up+1]=='*' ) up = up + 1;
+        }
+
+        if(up && up != 2)
+        {
+            fprintf(stderr,"Missing unphased marker '*': [%c][%s]", ss[2+up], tsv->ss);
+            return -1;
+        }
+
+        // change alleles to unphased if the alleles are unphased
+        if ( up )
+        {
+            args->gts[2*i] = bcf_gt_unphased(bcf_gt_allele(args->gts[2*i]));
+            args->gts[2*i+1] = bcf_gt_unphased(bcf_gt_allele(args->gts[2*i+1]));
+        }
+        nup = nup + up;
+    }
+    if ( tsv->ss[(nsamples-1)*4+3+nup] )
+    {
+        fprintf(stderr,"nup: %d", nup);
+        fprintf(stderr,"Wrong number of fields (%d-th column = [%c]). ", nsamples*2,tsv->ss[(nsamples-1)*4+nup]);
+        return -1;
+    }
+
+    if ( bcf_update_genotypes(args->header,rec,args->gts,nsamples*2) ) error("Could not update GT field\n");
+    return 0;
+}
+static void gensample_to_vcf(args_t *args)
+{
+    /*
+     *  Inpute: IMPUTE2 output (indentation changed here for clarity):
+     *
+     *      20:62116619_C_T 20:62116619     62116619 C T 0.969 0.031 0 ...
+     *      ---             20:62116698_C_A 62116698 C A 1     0     0 ...
+     *
+     *  Second column is expected in the form of CHROM:POS_REF_ALT. We use second
+     *  column because the first can be empty ("--") when filling sites from reference
+     *  panel. When the option --vcf-ids is given, the first column is used to set the
+     *  VCF ID.
+     *
+     *  Output: VCF with filled GT,GP
+     *
+     */
+    kstring_t line = {0,0,0};
+
+    char *gen_fname = NULL, *sample_fname = NULL;
+    sample_fname = strchr(args->infname,',');
+    if ( !sample_fname )
+    {
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.gen.gz", args->infname);
+        gen_fname = strdup(args->str.s);
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.samples", args->infname);
+        sample_fname = strdup(args->str.s);
+    }
+    else
+    {
+        *sample_fname = 0;
+        gen_fname = strdup(args->infname);
+        sample_fname = strdup(sample_fname+1);
+    }
+    htsFile *gen_fh = hts_open(gen_fname, "r");
+    if ( !gen_fh ) error("Could not read: %s\n", gen_fname);
+    if ( hts_getline(gen_fh, KS_SEP_LINE, &line) <= 0 ) error("Empty file: %s\n", gen_fname);
+
+    // Find out the chromosome name, depending on the format variant (--3N6 or plain) and the ordering
+    // of the columns (CHROM:POS_REF_ALT comes first or second)
+    args->str.l = 0;
+    char *sb = line.s, *se = line.s;
+    while ( *se && !isspace(*se) ) se++;
+    if ( !*se ) error("Could not determine CHROM in %s: %s\n", gen_fname,line.s);
+    if ( args->gen_3N6 )    // first column, just CHROM
+        kputsn(sb, se-sb, &args->str);
+    else                    // first or second column, part of CHROM:POS_REF_ALT
+    {
+        char *sc = strchr(sb,':');
+        if ( !sc || sc > se )
+        {
+            while ( *se && !isspace(*se) ) se++;
+            if ( !*se ) error("Could not determine CHROM in %s: %s\n", gen_fname,line.s);
+            sb = ++se;
+            sc = strchr(sb,':');
+            if ( !sc ) error("Could not determine CHROM in %s: %s\n", gen_fname,line.s);
+        }
+        kputsn(sb, sc-sb, &args->str);
+    }
+
+    // Initialize and print the VCF header, args->str.s contains the chr name
+    args->header = bcf_hdr_init("w");
+    bcf_hdr_append(args->header, "##INFO=<ID=END,Number=1,Type=Integer,Description=\"End position of the variant described in this record\">");
+    bcf_hdr_append(args->header, "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">");
+    bcf_hdr_append(args->header, "##FORMAT=<ID=GP,Number=G,Type=Float,Description=\"Genotype Probabilities\">");
+    bcf_hdr_printf(args->header, "##contig=<ID=%s,length=%d>", args->str.s,0x7fffffff);   // MAX_CSI_COOR
+    if (args->record_cmd_line) bcf_hdr_append_version(args->header, args->argc, args->argv, "bcftools_convert");
+
+    tsv_t *tsv;
+    if ( args->gen_3N6 )
+    {
+        tsv = tsv_init("CHROM,CHROM_POS_REF_ALT,ID,POS,REF_ALT,GT_GP");
+        tsv_register(tsv, "CHROM", tsv_setter_chrom, args->header);
+    }
+    else
+        tsv = tsv_init("CHROM_POS_REF_ALT,ID,POS,REF_ALT,GT_GP");
+    tsv_register(tsv, "CHROM_POS_REF_ALT", tsv_setter_chrom_pos_ref_alt_or_id, args);
+    tsv_register(tsv, "ID", tsv_setter_chrom_pos_ref_alt_id_or_die, args);
+    tsv_register(tsv, "POS", tsv_setter_verify_pos, NULL);
+    tsv_register(tsv, "REF_ALT", tsv_setter_verify_ref_alt, args);
+    tsv_register(tsv, "GT_GP", tsv_setter_gt_gp, args);
+
+    // Find out sample names
+    int i, nsamples;
+    char **samples = hts_readlist(sample_fname, 1, &nsamples);
+    if ( !samples ) error("Could not read %s\n", sample_fname);
+    for (i=2; i<nsamples; i++)
+    {
+        se = samples[i]; while ( *se && !isspace(*se) ) se++;
+        *se = 0;
+        bcf_hdr_add_sample(args->header,samples[i]);
+    }
+    for (i=0; i<nsamples; i++) free(samples[i]);
+    free(samples);
+
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+    if ( bcf_hdr_write(out_fh,args->header)!=0 ) error("[%s] Error: cannot write the header to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,args->header,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+    bcf1_t *rec = bcf_init();
+
+    nsamples -= 2;
+    args->gts = (int32_t *) malloc(sizeof(int32_t)*nsamples*2);
+    args->flt = (float *) malloc(sizeof(float)*nsamples*3);
+
+    do
+    {
+        bcf_clear(rec);
+        args->n.total++;
+        if ( !tsv_parse(tsv, rec, line.s) )
+        {
+            if ( bcf_write(out_fh, args->header, rec)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+        }
+        else
+            error("Error occurred while parsing: %s\n", line.s);
+    }
+    while ( hts_getline(gen_fh, KS_SEP_LINE, &line)>0 );
+
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+    if ( hts_close(gen_fh) ) error("Close failed: %s\n", gen_fname);
+    bcf_hdr_destroy(args->header);
+    bcf_destroy(rec);
+    free(sample_fname);
+    free(gen_fname);
+    free(args->str.s);
+    free(line.s);
+    free(args->gts);
+    free(args->flt);
+    tsv_destroy(tsv);
+
+    fprintf(stderr,"Number of processed rows: \t%d\n", args->n.total);
+}
+
+static void haplegendsample_to_vcf(args_t *args)
+{
+    /*
+     *  Convert from IMPUTE2 hap/legend/sample output files to VCF
+     *
+     *      hap:
+     *          0 1 0 1
+     *      legend:
+     *          id position a0 a1
+     *          1:186946386_G_T 186946386 G T
+     *      sample:
+     *          sample population group sex
+     *          sample1 sample1 sample1 2
+     *          sample2 sample2 sample2 2
+     *
+     *  Output: VCF with filled GT
+     */
+    kstring_t line = {0,0,0};
+
+    if ( args->output_vcf_ids )
+        error(
+            "The option --haplegendsample2vcf cannot be combined with --vcf-ids. This is because the\n"
+            "ID column must be formatted as \"CHROM:POS_REF_ALT\" to check sanity of the operation\n");
+
+    char *hap_fname = NULL, *leg_fname = NULL, *sample_fname = NULL;
+    sample_fname = strchr(args->infname,',');
+    if ( !sample_fname )
+    {
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.hap.gz", args->infname);
+        hap_fname = strdup(args->str.s);
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.samples", args->infname);
+        sample_fname = strdup(args->str.s);
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.legend.gz", args->infname);
+        leg_fname = strdup(args->str.s);
+    }
+    else
+    {
+        char *ss = sample_fname, *se = strchr(ss+1,',');
+        if ( !se ) error("Could not parse hap/legend/sample file names: %s\n", args->infname);
+        *ss = 0;
+        *se = 0;
+        hap_fname = strdup(args->infname);
+        leg_fname = strdup(ss+1);
+        sample_fname = strdup(se+1);
+    }
+    htsFile *hap_fh = hts_open(hap_fname, "r");
+    if ( !hap_fh ) error("Could not read: %s\n", hap_fname);
+
+    htsFile *leg_fh = hts_open(leg_fname,"r");
+    if ( !leg_fh ) error("Could not read: %s\n", leg_fname);
+
+    // Eat up first legend line, then determine chromosome name
+    if ( hts_getline(leg_fh, KS_SEP_LINE, &line) <= 0 ) error("Empty file: %s\n", leg_fname);
+    if ( hts_getline(leg_fh, KS_SEP_LINE, &line) <= 0 ) error("Empty file: %s\n", leg_fname);
+
+    // Find out the chromosome name, sample names, init and print the VCF header
+    args->str.l = 0;
+    char *se = strchr(line.s,':');
+    if ( !se ) error("Expected CHROM:POS_REF_ALT in first column of %s\n", leg_fname);
+    kputsn(line.s, se-line.s, &args->str);
+
+    tsv_t *leg_tsv = tsv_init("CHROM_POS_REF_ALT,POS,REF_ALT");
+    tsv_register(leg_tsv, "CHROM_POS_REF_ALT", tsv_setter_chrom_pos_ref_alt, args);
+    tsv_register(leg_tsv, "POS", tsv_setter_verify_pos, NULL);
+    tsv_register(leg_tsv, "REF_ALT", tsv_setter_verify_ref_alt, args);
+    tsv_t *hap_tsv = tsv_init("HAPS");
+    tsv_register(hap_tsv, "HAPS", tsv_setter_haps, args);
+
+    args->header = bcf_hdr_init("w");
+    bcf_hdr_append(args->header, "##INFO=<ID=END,Number=1,Type=Integer,Description=\"End position of the variant described in this record\">");
+    bcf_hdr_append(args->header, "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">");
+    bcf_hdr_printf(args->header, "##contig=<ID=%s,length=%d>", args->str.s,0x7fffffff);   // MAX_CSI_COOR
+    if (args->record_cmd_line) bcf_hdr_append_version(args->header, args->argc, args->argv, "bcftools_convert");
+
+    int i, nrows, nsamples;
+    char **samples = hts_readlist(sample_fname, 1, &nrows);
+    if ( !samples ) error("Could not read %s\n", sample_fname);
+    nsamples = nrows - 1;
+
+    // sample_fname should contain a header line, so need to ignore first row
+    // returned from hts_readlist (i=1, and not i=0)
+    for (i=1; i<nrows; i++)
+    {
+        se = samples[i]; while ( *se && !isspace(*se) ) se++;
+        *se = 0;
+        bcf_hdr_add_sample(args->header,samples[i]);
+    }
+    bcf_hdr_add_sample(args->header,NULL);
+    for (i=0; i<nrows; i++) free(samples[i]);
+    free(samples);
+
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+    if ( bcf_hdr_write(out_fh,args->header)!=0 ) error("[%s] Error: cannot write the header to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,args->header,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+    bcf1_t *rec = bcf_init();
+
+    args->gts = (int32_t *) malloc(sizeof(int32_t)*nsamples*2);
+
+    while (1)
+    {
+        bcf_clear(rec);
+        args->n.total++;
+        if ( tsv_parse(leg_tsv, rec, line.s) )
+            error("Error occurred while parsing %s: %s\n", leg_fname,line.s);
+
+        if ( hts_getline(hap_fh,  KS_SEP_LINE, &line)<=0 )
+            error("Different number of records in %s and %s?\n", leg_fname,hap_fname);
+
+        if ( tsv_parse(hap_tsv, rec, line.s) )
+            error("Error occurred while parsing %s: %s\n", hap_fname,line.s);
+
+        if ( bcf_write(out_fh, args->header, rec)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+
+        if ( hts_getline(leg_fh, KS_SEP_LINE, &line)<=0 )
+        {
+            if ( hts_getline(hap_fh, KS_SEP_LINE, &line)>0 )
+                error("Different number of records in %s and %s?\n", leg_fname,hap_fname);
+            break;
+        }
+    }
+
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+    if ( hts_close(hap_fh) ) error("Close failed: %s\n", hap_fname);
+    if ( hts_close(leg_fh) ) error("Close failed: %s\n", leg_fname);
+    bcf_hdr_destroy(args->header);
+    bcf_destroy(rec);
+    free(sample_fname);
+    free(hap_fname);
+    free(leg_fname);
+    free(args->str.s);
+    free(line.s);
+    free(args->gts);
+    tsv_destroy(hap_tsv);
+    tsv_destroy(leg_tsv);
+
+    fprintf(stderr,"Number of processed rows: \t%d\n", args->n.total);
+}
+
+static void hapsample_to_vcf(args_t *args)
+{
+    /*
+     *  Input: SHAPEIT output
+     *
+     *      20:19995888_A_G rsid1 19995888 A G 0 0 0 0 ...
+     *      20 20:19995888_A_G 19995888 A G 0 0 0 0 ...
+     *
+     *  First column is expected in the form of CHROM:POS_REF_ALT
+     *
+     *  Output: VCF with filled GT
+     *
+     */
+    kstring_t line = {0,0,0};
+
+    char *hap_fname = NULL, *sample_fname = NULL;
+    sample_fname = strchr(args->infname,',');
+    if ( !sample_fname )
+    {
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.hap.gz", args->infname);
+        hap_fname = strdup(args->str.s);
+        args->str.l = 0;
+        ksprintf(&args->str,"%s.samples", args->infname);
+        sample_fname = strdup(args->str.s);
+    }
+    else
+    {
+        *sample_fname = 0;
+        hap_fname = strdup(args->infname);
+        sample_fname = strdup(sample_fname+1);
+    }
+    htsFile *hap_fh = hts_open(hap_fname, "r");
+    if ( !hap_fh ) error("Could not read: %s\n", hap_fname);
+    if ( hts_getline(hap_fh, KS_SEP_LINE, &line) <= 0 ) error("Empty file: %s\n", hap_fname);
+
+    // Find out the chromosome name, it can be either in the first or second column
+    args->str.l = 0;
+    char *sb = line.s, *se = line.s;
+    while ( *se && !isspace(*se) ) se++;
+    if ( !*se ) error("Could not determine CHROM in %s: %s\n", hap_fname,line.s);
+    if ( !args->output_vcf_ids )
+    {
+        // first column should be just CHROM, but the second must be CHROM:POS_REF_ALT, use that
+        sb = ++se;
+        while ( *se && !isspace(*se) ) se++;
+        if ( !*se ) error("Could not determine CHROM in %s: %s\n", hap_fname,line.s);
+        if ( !strchr(sb,':') )
+            error("Could not determine CHROM in the second column of %s: %s\n", hap_fname,line.s);
+    }
+    // Parse CHROM:POS_REF_ALT
+    char *sc = strchr(sb,':');
+    if ( !sc || sc > se )
+        error("Could not determine CHROM in %s: %s\n", hap_fname,line.s);
+    kputsn(sb, sc-sb, &args->str);
+
+    // Initialize and print the VCF header, args->str.s contains the chr name
+    args->header = bcf_hdr_init("w");
+    bcf_hdr_append(args->header, "##INFO=<ID=END,Number=1,Type=Integer,Description=\"End position of the variant described in this record\">");
+    bcf_hdr_append(args->header, "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">");
+    bcf_hdr_printf(args->header, "##contig=<ID=%s,length=%d>", args->str.s,0x7fffffff);   // MAX_CSI_COOR
+    if (args->record_cmd_line) bcf_hdr_append_version(args->header, args->argc, args->argv, "bcftools_convert");
+
+    tsv_t *tsv;
+    if ( args->output_vcf_ids )
+    {
+        tsv = tsv_init("CHROM_POS_REF_ALT,ID,POS,REF_ALT,HAPS");
+        tsv_register(tsv, "ID", tsv_setter_id, args);
+    }
+    else
+    {
+        tsv = tsv_init("CHROM,CHROM_POS_REF_ALT,POS,REF_ALT,HAPS");
+        tsv_register(tsv, "CHROM", tsv_setter_chrom_pos_ref_alt_or_chrom, args);
+    }
+    tsv_register(tsv, "CHROM_POS_REF_ALT", tsv_setter_chrom_pos_ref_alt, args);
+    tsv_register(tsv, "POS", tsv_setter_verify_pos, NULL);
+    tsv_register(tsv, "REF_ALT", tsv_setter_verify_ref_alt, args);
+    tsv_register(tsv, "HAPS", tsv_setter_haps, args);
+
+    int i, nsamples;
+    char **samples = hts_readlist(sample_fname, 1, &nsamples);
+    if ( !samples ) error("Could not read %s\n", sample_fname);
+    for (i=2; i<nsamples; i++)
+    {
+        se = samples[i]; while ( *se && !isspace(*se) ) se++;
+        *se = 0;
+        bcf_hdr_add_sample(args->header,samples[i]);
+    }
+    bcf_hdr_add_sample(args->header,NULL);
+    for (i=0; i<nsamples; i++) free(samples[i]);
+    free(samples);
+
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+    if ( bcf_hdr_write(out_fh,args->header)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,args->header,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+    bcf1_t *rec = bcf_init();
+
+    nsamples -= 2;
+    args->gts = (int32_t *) malloc(sizeof(int32_t)*nsamples*2);
+
+    do
+    {
+        bcf_clear(rec);
+        args->n.total++;
+        if ( !tsv_parse(tsv, rec, line.s) )
+        {
+            if ( bcf_write(out_fh, args->header, rec)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+        }
+        else
+            error("Error occurred while parsing: %s\n", line.s);
+    }
+    while ( hts_getline(hap_fh, KS_SEP_LINE, &line)>0 );
+
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+    if ( hts_close(hap_fh) ) error("Close failed: %s\n", hap_fname);
+    bcf_hdr_destroy(args->header);
+    bcf_destroy(rec);
+    free(sample_fname);
+    free(hap_fname);
+    free(args->str.s);
+    free(line.s);
+    free(args->gts);
+    tsv_destroy(tsv);
+
+    fprintf(stderr,"Number of processed rows: \t%d\n", args->n.total);
+}
+
+char *init_sample2sex(bcf_hdr_t *hdr, char *sex_fname)
+{
+    int i, nlines;
+    char *sample2sex = (char*) calloc(bcf_hdr_nsamples(hdr),1);
+    char **lines = hts_readlist(sex_fname, 1, &nlines);
+    if ( !lines ) error("Could not read %s\n", sex_fname);
+    for (i=0; i<nlines; i++)
+    {
+        char *se = lines[i]; while ( *se && !isspace(*se) ) se++;
+        char tmp = *se;
+        *se = 0;
+        int id = bcf_hdr_id2int(hdr, BCF_DT_SAMPLE, lines[i]);
+        *se = tmp;
+        if ( id<0 ) continue;
+        while ( *se && isspace(*se) ) se++;
+        if ( *se=='M' ) sample2sex[id] = '1';
+        else if ( *se=='F' ) sample2sex[id] = '2';
+        else error("Could not parse %s: %s\n", sex_fname,lines[i]);
+    }
+    for (i=0; i<nlines; i++) free(lines[i]);
+    free(lines);
+    for (i=0; i<bcf_hdr_nsamples(hdr); i++)
+        if ( !sample2sex[i] ) error("Missing sex for sample %s in %s\n", bcf_hdr_int2id(hdr, BCF_DT_SAMPLE, i),sex_fname);
+    return sample2sex;
+}
+
+static void vcf_to_gensample(args_t *args)
+{
+    kstring_t str = {0,0,0};
+
+    // insert chrom as first column if needed
+    if ( args->gen_3N6 )
+        kputs("%CHROM ", &str);
+
+    kputs("%CHROM:%POS\\_%REF\\_%FIRST_ALT ", &str);
+
+    // insert rsid as second column if needed
+    if ( args->output_vcf_ids )
+        kputs("%ID ", &str);
+    else
+        kputs("%CHROM:%POS\\_%REF\\_%FIRST_ALT ", &str);
+
+    kputs("%POS %REF %FIRST_ALT", &str);
+    if ( !args->tag || !strcmp(args->tag,"GT") ) kputs("%_GT_TO_PROB3",&str);
+    else if ( !strcmp(args->tag,"PL") ) kputs("%_PL_TO_PROB3",&str);
+    else if ( !strcmp(args->tag,"GP") ) kputs("%_GP_TO_PROB3",&str);
+    else error("todo: --tag %s\n", args->tag);
+    kputs("\n", &str);
+    open_vcf(args,str.s);
+
+    int ret, gen_compressed = 1, sample_compressed = 0;
+    char *gen_fname = NULL, *sample_fname = NULL;
+    str.l = 0;
+    kputs(args->outfname,&str);
+    int n_files = 0, i;
+    char **files = hts_readlist(str.s, 0, &n_files);
+    if ( n_files==1 )
+    {
+        int l = str.l;
+        kputs(".samples",&str);
+        sample_fname = strdup(str.s);
+        str.l = l;
+        kputs(".gen.gz",&str);
+        gen_fname = strdup(str.s);
+    }
+    else if ( n_files==2 )
+    {
+        if (strlen(files[0]) && strcmp(files[0],".")!=0) gen_fname = strdup(files[0]);
+        if (strlen(files[1]) && strcmp(files[1],".")!=0) sample_fname = strdup(files[1]);
+    }
+    else
+    {
+        error("Error parsing --gensample filenames: %s\n", args->outfname);
+    }
+    for (i=0; i<n_files; i++) free(files[i]);
+    free(files);
+
+    if ( gen_fname && (strlen(gen_fname)<3 || strcasecmp(".gz",gen_fname+strlen(gen_fname)-3)) ) gen_compressed = 0;
+    if ( sample_fname && strlen(sample_fname)>3 && strcasecmp(".gz",sample_fname+strlen(sample_fname)-3)==0 ) sample_compressed = 0;
+
+    if (gen_fname) fprintf(stderr, "Gen file: %s\n", gen_fname);
+    if (sample_fname) fprintf(stderr, "Sample file: %s\n", sample_fname);
+
+    // write samples file
+    if (sample_fname)
+    {
+        char *sample2sex = NULL;
+        if ( args->sex_fname ) sample2sex = init_sample2sex(args->header,args->sex_fname);
+
+        int i;
+        BGZF *sout = bgzf_open(sample_fname, sample_compressed ? "wg" : "wu");
+        str.l = 0;
+        kputs(sample2sex ? "ID_1 ID_2 missing sex\n0 0 0 0\n" : "ID_1 ID_2 missing\n0 0 0\n", &str);
+        ret = bgzf_write(sout, str.s, str.l);
+        if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        for (i=0; i<bcf_hdr_nsamples(args->header); i++)
+        {
+            str.l = 0;
+            if ( sample2sex )
+                ksprintf(&str, "%s %s 0 %c\n", args->header->samples[i],args->header->samples[i],sample2sex[i]);
+            else
+                ksprintf(&str, "%s %s 0\n", args->header->samples[i],args->header->samples[i]);
+            ret = bgzf_write(sout, str.s, str.l);
+            if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        }
+        if ( bgzf_close(sout)!=0 ) error("Error closing %s: %s\n", sample_fname, strerror(errno));
+        free(sample_fname);
+        free(sample2sex);
+    }
+    if (!gen_fname) {
+        if ( str.m ) free(str.s);
+        return;
+    }
+
+    int prev_rid = -1, prev_pos = -1;
+    int no_alt = 0, non_biallelic = 0, filtered = 0, ndup = 0, nok = 0;
+    BGZF *gout = bgzf_open(gen_fname, gen_compressed ? "wg" : "wu");
+    while ( bcf_sr_next_line(args->files) )
+    {
+        bcf1_t *line = bcf_sr_get_line(args->files,0);
+        if ( args->filter )
+        {
+            int pass = filter_test(args->filter, line, NULL);
+            if ( args->filter_logic & FLT_EXCLUDE ) pass = pass ? 0 : 1;
+            if ( !pass ) { filtered++; continue; }
+        }
+
+        // ALT allele is required
+        if ( line->n_allele<2 ) { no_alt++; continue; }
+
+        // biallelic required
+        if ( line->n_allele>2 ) {
+            if (!non_biallelic)
+                fprintf(stderr, "Warning: non-biallelic records are skipped. Consider splitting multi-allelic records into biallelic records using 'bcftools norm -m-'.\n");
+            non_biallelic++;
+            continue;
+        }
+
+        // skip duplicate lines, or otherwise shapeit complains
+        if ( !args->keep_duplicates && prev_rid==line->rid && prev_pos==line->pos ) { ndup++; continue; }
+        prev_rid = line->rid;
+        prev_pos = line->pos;
+
+        str.l = 0;
+        convert_line(args->convert, line, &str);
+        if ( str.l )
+        {
+            int ret = bgzf_write(gout, str.s, str.l);
+            if ( ret!= str.l ) error("Error writing %s: %s\n", gen_fname,strerror(errno));
+            nok++;
+        }
+    }
+    fprintf(stderr, "%d records written, %d skipped: %d/%d/%d/%d no-ALT/non-biallelic/filtered/duplicated\n",
+        nok, no_alt+non_biallelic+filtered+ndup, no_alt, non_biallelic, filtered, ndup);
+
+    if ( str.m ) free(str.s);
+    if ( bgzf_close(gout)!=0 ) error("Error closing %s: %s\n", gen_fname,strerror(errno));
+    free(gen_fname);
+}
+
+static void vcf_to_haplegendsample(args_t *args)
+{
+    kstring_t str = {0,0,0};
+    if ( args->hap2dip )
+        kputs("%_GT_TO_HAP2\n", &str);
+    else
+        kputs("%_GT_TO_HAP\n", &str);
+    open_vcf(args,str.s);
+
+    int ret, hap_compressed = 1, legend_compressed = 1, sample_compressed = 0;
+    char *hap_fname = NULL, *legend_fname = NULL, *sample_fname = NULL;
+    str.l = 0;
+    kputs(args->outfname,&str);
+    int n_files = 0, i;
+    char **files = hts_readlist(str.s, 0, &n_files);
+    if ( n_files==1 )
+    {
+        int l = str.l;
+        kputs(".samples",&str);
+        sample_fname = strdup(str.s);
+        str.l = l;
+        kputs(".legend.gz",&str);
+        legend_fname = strdup(str.s);
+        str.l = l;
+        kputs(".hap.gz",&str);
+        hap_fname = strdup(str.s);
+    }
+    else if ( n_files==3 )
+    {
+        if (strlen(files[0]) && strcmp(files[0],".")!=0) hap_fname = strdup(files[0]);
+        if (strlen(files[1]) && strcmp(files[1],".")!=0) legend_fname = strdup(files[1]);
+        if (strlen(files[2]) && strcmp(files[2],".")!=0) sample_fname = strdup(files[2]);
+    }
+    else
+    {
+        error("Error parsing --hapslegendsample filenames: %s\n", args->outfname);
+    }
+    for (i=0; i<n_files; i++) free(files[i]);
+    free(files);
+
+    if ( hap_fname && (strlen(hap_fname)<3 || strcasecmp(".gz",hap_fname+strlen(hap_fname)-3)) ) hap_compressed = 0;
+    if ( legend_fname && (strlen(legend_fname)<3 || strcasecmp(".gz",legend_fname+strlen(legend_fname)-3)) ) legend_compressed = 0;
+    if ( sample_fname && strlen(sample_fname)>3 && strcasecmp(".gz",sample_fname+strlen(sample_fname)-3)==0 ) sample_compressed = 0;
+
+    if (hap_fname) fprintf(stderr, "Hap file: %s\n", hap_fname);
+    if (legend_fname) fprintf(stderr, "Legend file: %s\n", legend_fname);
+    if (sample_fname) fprintf(stderr, "Sample file: %s\n", sample_fname);
+
+    // write samples file
+    if (sample_fname)
+    {
+        char *sample2sex = NULL;
+        if ( args->sex_fname ) sample2sex = init_sample2sex(args->header,args->sex_fname);
+
+        int i;
+        BGZF *sout = bgzf_open(sample_fname, sample_compressed ? "wg" : "wu");
+        str.l = 0;
+        kputs("sample population group sex\n", &str);
+        ret = bgzf_write(sout, str.s, str.l);
+        if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        for (i=0; i<bcf_hdr_nsamples(args->header); i++)
+        {
+            str.l = 0;
+            ksprintf(&str, "%s %s %s %c\n", args->header->samples[i], args->header->samples[i], args->header->samples[i], sample2sex ? sample2sex[i] : '2');
+            ret = bgzf_write(sout, str.s, str.l);
+            if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        }
+        if ( bgzf_close(sout)!=0 ) error("Error closing %s: %s\n", sample_fname, strerror(errno));
+        free(sample_fname);
+        free(sample2sex);
+    }
+    if (!hap_fname && !legend_fname) {
+        if ( str.m ) free(str.s);
+        return;
+    }
+
+    // open haps and legend outputs
+    BGZF *hout = hap_fname ? bgzf_open(hap_fname, hap_compressed ? "wg" : "wu") : NULL;
+    if ( hap_compressed && args->n_threads ) bgzf_thread_pool(hout, args->files->p->pool, args->files->p->qsize);
+    BGZF *lout = legend_fname ? bgzf_open(legend_fname, legend_compressed ? "wg" : "wu") : NULL;
+    if (legend_fname) {
+        str.l = 0;
+        kputs("id position a0 a1\n", &str);
+        ret = bgzf_write(lout, str.s, str.l);
+        if ( ret != str.l ) error("Error writing %s: %s\n", legend_fname, strerror(errno));
+    }
+
+    int no_alt = 0, non_biallelic = 0, filtered = 0, nok = 0;
+    while ( bcf_sr_next_line(args->files) )
+    {
+        bcf1_t *line = bcf_sr_get_line(args->files,0);
+        if ( args->filter )
+        {
+            int pass = filter_test(args->filter, line, NULL);
+            if ( args->filter_logic & FLT_EXCLUDE ) pass = pass ? 0 : 1;
+            if ( !pass ) { filtered++; continue; }
+        }
+
+        // ALT allele is required
+        if ( line->n_allele<2 ) { no_alt++; continue; }
+        // biallelic required
+        if ( line->n_allele>2 ) {
+            if (!non_biallelic)
+                fprintf(stderr, "Warning: non-biallelic records are skipped. Consider splitting multi-allelic records into biallelic records using 'bcftools norm -m-'.\n");
+            non_biallelic++;
+            continue;
+        }
+
+        str.l = 0;
+        convert_line(args->convert, line, &str);
+        if ( !str.l ) continue;
+
+        // write haps file
+        if (hap_fname) {
+            ret = bgzf_write(hout, str.s, str.l); // write hap file
+            if ( ret != str.l ) error("Error writing %s: %s\n", hap_fname, strerror(errno));
+        }
+        if (legend_fname) {
+            str.l = 0;
+            if ( args->output_vcf_ids && (line->d.id[0]!='.' || line->d.id[1]!=0) )
+                ksprintf(&str, "%s %"PRId64" %s %s\n", line->d.id, (int64_t) line->pos+1, line->d.allele[0], line->d.allele[1]);
+            else
+                ksprintf(&str, "%s:%"PRId64"_%s_%s %"PRId64" %s %s\n", bcf_seqname(args->header, line), (int64_t) line->pos+1, line->d.allele[0], line->d.allele[1], (int64_t) line->pos+1, line->d.allele[0], line->d.allele[1]);
+
+            // write legend file
+            ret = bgzf_write(lout, str.s, str.l);
+            if ( ret != str.l ) error("Error writing %s: %s\n", legend_fname, strerror(errno));
+        }
+        nok++;
+    }
+    fprintf(stderr, "%d records written, %d skipped: %d/%d/%d no-ALT/non-biallelic/filtered\n", nok,no_alt+non_biallelic+filtered, no_alt, non_biallelic, filtered);
+    if ( str.m ) free(str.s);
+    if ( hout && bgzf_close(hout)!=0 ) error("Error closing %s: %s\n", hap_fname, strerror(errno));
+    if ( lout && bgzf_close(lout)!=0 ) error("Error closing %s: %s\n", legend_fname, strerror(errno));
+    if (hap_fname) free(hap_fname);
+    if (legend_fname) free(legend_fname);
+}
+
+static void vcf_to_hapsample(args_t *args)
+{
+    /*
+     *  WTCCC style haplotypes file
+     *  see https://mathgen.stats.ox.ac.uk/genetics_software/shapeit/shapeit.html#hapsample
+     *
+     *  These are essentially the haplotypes from the impute2 format with some
+     *  legend info tacked on to the first 5 columns
+     *
+     */
+    kstring_t str = {0,0,0};
+
+    // print ID instead of CHROM:POS_REF_ALT1
+    if ( args->output_vcf_ids )
+        kputs("%CHROM:%POS\\_%REF\\_%FIRST_ALT %ID %POS %REF %FIRST_ALT ", &str);
+    else
+        kputs("%CHROM %CHROM:%POS\\_%REF\\_%FIRST_ALT %POS %REF %FIRST_ALT ", &str);
+
+    if ( args->hap2dip )
+        kputs("%_GT_TO_HAP2\n", &str);
+    else
+        kputs("%_GT_TO_HAP\n", &str);
+    open_vcf(args,str.s);
+
+    int ret, hap_compressed = 1, sample_compressed = 0;
+    char *hap_fname = NULL, *sample_fname = NULL;
+    str.l = 0;
+    kputs(args->outfname,&str);
+    int n_files = 0, i;
+    char **files = hts_readlist(str.s, 0, &n_files);
+    if ( n_files==1 )
+    {
+        int l = str.l;
+        kputs(".samples",&str);
+        sample_fname = strdup(str.s);
+        str.l = l;
+        kputs(".hap.gz",&str);
+        hap_fname = strdup(str.s);
+    }
+    else if ( n_files==2 )
+    {
+        if (strlen(files[0]) && strcmp(files[0],".")!=0) hap_fname = strdup(files[0]);
+        if (strlen(files[1]) && strcmp(files[1],".")!=0) sample_fname = strdup(files[1]);
+    }
+    else
+    {
+        error("Error parsing --hapsample filenames: %s\n", args->outfname);
+    }
+    for (i=0; i<n_files; i++) free(files[i]);
+    free(files);
+
+    if ( hap_fname && (strlen(hap_fname)<3 || strcasecmp(".gz",hap_fname+strlen(hap_fname)-3)) ) hap_compressed = 0;
+    if ( sample_fname && strlen(sample_fname)>3 && strcasecmp(".gz",sample_fname+strlen(sample_fname)-3)==0 ) sample_compressed = 0;
+
+    if (hap_fname) fprintf(stderr, "Hap file: %s\n", hap_fname);
+    if (sample_fname) fprintf(stderr, "Sample file: %s\n", sample_fname);
+
+    // write samples file
+    if (sample_fname)
+    {
+        char *sample2sex = NULL;
+        if ( args->sex_fname ) sample2sex = init_sample2sex(args->header,args->sex_fname);
+
+        int i;
+        BGZF *sout = bgzf_open(sample_fname, sample_compressed ? "wg" : "wu");
+        str.l = 0;
+        kputs(sample2sex ? "ID_1 ID_2 missing sex\n0 0 0 0\n" : "ID_1 ID_2 missing\n0 0 0\n", &str);
+        ret = bgzf_write(sout, str.s, str.l);
+        if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        for (i=0; i<bcf_hdr_nsamples(args->header); i++)
+        {
+            str.l = 0;
+            if ( sample2sex )
+                ksprintf(&str, "%s %s 0 %c\n", args->header->samples[i],args->header->samples[i],sample2sex[i]);
+            else
+                ksprintf(&str, "%s %s 0\n", args->header->samples[i],args->header->samples[i]);
+            ret = bgzf_write(sout, str.s, str.l);
+            if ( ret != str.l ) error("Error writing %s: %s\n", sample_fname, strerror(errno));
+        }
+        if ( bgzf_close(sout)!=0 ) error("Error closing %s: %s\n", sample_fname, strerror(errno));
+        free(sample_fname);
+        free(sample2sex);
+    }
+    if (!hap_fname) {
+        if ( str.m ) free(str.s);
+        return;
+    }
+
+    // open haps output
+    BGZF *hout = hap_fname ? bgzf_open(hap_fname, hap_compressed ? "wg" : "wu") : NULL;
+    if ( hap_compressed && args->n_threads ) bgzf_thread_pool(hout, args->files->p->pool, args->files->p->qsize);
+
+    int no_alt = 0, non_biallelic = 0, filtered = 0, nok = 0;
+    while ( bcf_sr_next_line(args->files) )
+    {
+        bcf1_t *line = bcf_sr_get_line(args->files,0);
+        if ( args->filter )
+        {
+            int pass = filter_test(args->filter, line, NULL);
+            if ( args->filter_logic & FLT_EXCLUDE ) pass = pass ? 0 : 1;
+            if ( !pass ) { filtered++; continue; }
+        }
+
+        // ALT allele is required
+        if ( line->n_allele<2 ) { no_alt++; continue; }
+        // biallelic required
+        if ( line->n_allele>2 ) {
+            if (!non_biallelic)
+                fprintf(stderr, "Warning: non-biallelic records are skipped. Consider splitting multi-allelic records into biallelic records using 'bcftools norm -m-'.\n");
+            non_biallelic++;
+            continue;
+        }
+
+        str.l = 0;
+        convert_line(args->convert, line, &str);
+        if ( !str.l ) continue;
+
+        // write haps file
+        if (hap_fname) {
+            ret = bgzf_write(hout, str.s, str.l); // write hap file
+            if ( ret != str.l ) error("Error writing %s: %s\n", hap_fname, strerror(errno));
+        }
+        nok++;
+    }
+    fprintf(stderr, "%d records written, %d skipped: %d/%d/%d no-ALT/non-biallelic/filtered\n", nok, no_alt+non_biallelic+filtered, no_alt, non_biallelic, filtered);
+    if ( str.m ) free(str.s);
+    if ( hout && bgzf_close(hout)!=0 ) error("Error closing %s: %s\n", hap_fname, strerror(errno));
+    if (hap_fname) free(hap_fname);
+}
+
+static void bcf_hdr_set_chrs(bcf_hdr_t *hdr, faidx_t *fai)
+{
+    int i, n = faidx_nseq(fai);
+    for (i=0; i<n; i++)
+    {
+        const char *seq = faidx_iseq(fai,i);
+        int len = faidx_seq_len(fai, seq);
+        bcf_hdr_printf(hdr, "##contig=<ID=%s,length=%d>", seq,len);
+    }
+}
+static inline int acgt_to_5(char base)
+{
+    if ( base=='A' ) return 0;
+    if ( base=='C' ) return 1;
+    if ( base=='G' ) return 2;
+    if ( base=='T' ) return 3;
+    return 4;
+}
+static inline int tsv_setter_aa1(args_t *args, char *ss, char *se, int alleles[], int *nals, int ref, int32_t *gts)
+{
+    if ( se - ss > 2 ) return -1;   // currently only SNPs
+
+    if ( ss[0]=='-' || ss[0]=='.' )
+    {
+        // missing GT
+        gts[0] = bcf_gt_missing;
+        gts[1] = bcf_gt_missing;
+        args->n.missing++;
+        return 0;
+    }
+    if ( ss[0]=='I' ) return -2;    // skip insertions/deletions for now
+    if ( ss[0]=='D' ) return -2;
+
+    int a0 = acgt_to_5(toupper(ss[0]));
+    int a1 = ss[1] ? acgt_to_5(toupper(ss[1])) : a0;
+    if ( alleles[a0]<0 ) alleles[a0] = (*nals)++;
+    if ( alleles[a1]<0 ) alleles[a1] = (*nals)++;
+
+    gts[0] = bcf_gt_unphased(alleles[a0]);
+    gts[1] = ss[1] ? bcf_gt_unphased(alleles[a1]) : bcf_int32_vector_end;
+
+    if ( ref==a0 && ref==a1  ) args->n.hom_rr++;    // hom ref: RR
+    else if ( ref==a0 ) args->n.het_ra++;           // het: RA
+    else if ( ref==a1 ) args->n.het_ra++;           // het: AR
+    else if ( a0==a1 ) args->n.hom_aa++;            // hom-alt: AA
+    else args->n.het_aa++;                          // non-ref het: AA
+
+    return 0;
+}
+static int tsv_setter_aa(tsv_t *tsv, bcf1_t *rec, void *usr)
+{
+    args_t *args = (args_t*) usr;
+
+    int len;
+    char *ref = faidx_fetch_seq(args->ref, (char*)bcf_hdr_id2name(args->header,rec->rid), rec->pos, rec->pos, &len);
+    if ( !ref ) error("faidx_fetch_seq failed at %s:%"PRId64"\n", bcf_hdr_id2name(args->header,rec->rid),(int64_t) rec->pos+1);
+
+    int nals = 1, alleles[5] = { -1, -1, -1, -1, -1 };    // a,c,g,t,n
+    ref[0] = toupper(ref[0]);
+    int iref = acgt_to_5(ref[0]);
+    alleles[iref] = 0;
+
+    rec->n_sample = bcf_hdr_nsamples(args->header);
+
+    int i, ret;
+    for (i=0; i<rec->n_sample; i++)
+    {
+        if ( i>0 )
+        {
+            ret = tsv_next(tsv);
+            if ( ret==-1 ) error("Too few columns for %d samples at %s:%"PRId64"\n", rec->n_sample,bcf_hdr_id2name(args->header,rec->rid),(int64_t) rec->pos+1);
+        }
+        ret = tsv_setter_aa1(args, tsv->ss, tsv->se, alleles, &nals, iref, args->gts+i*2);
+        if ( ret==-1 ) error("Error parsing the site %s:%"PRId64", expected two characters\n", bcf_hdr_id2name(args->header,rec->rid),(int64_t) rec->pos+1);
+        if ( ret==-2 )
+        {
+            // something else than a SNP
+            free(ref);
+            return -1;
+        }
+    }
+
+    args->str.l = 0;
+    kputc(ref[0], &args->str);
+    for (i=0; i<5; i++)
+    {
+        if ( alleles[i]>0 )
+        {
+            kputc(',', &args->str);
+            kputc("ACGTN"[i], &args->str);
+        }
+    }
+    bcf_update_alleles_str(args->header, rec, args->str.s);
+    if ( bcf_update_genotypes(args->header,rec,args->gts,rec->n_sample*2) ) error("Could not update the GT field\n");
+
+    free(ref);
+    return 0;
+}
+
+static void tsv_to_vcf(args_t *args)
+{
+    if ( !args->ref_fname ) error("--tsv2vcf requires the --fasta-ref option\n");
+
+    args->ref = fai_load(args->ref_fname);
+    if ( !args->ref ) error("Could not load the reference %s\n", args->ref_fname);
+
+    args->header = bcf_hdr_init("w");
+    bcf_hdr_set_chrs(args->header, args->ref);
+    bcf_hdr_append(args->header, "##FORMAT=<ID=GT,Number=1,Type=String,Description=\"Genotype\">");
+    if (args->record_cmd_line) bcf_hdr_append_version(args->header, args->argc, args->argv, "bcftools_convert");
+
+    int i, nsmpl;
+    char **smpl;
+    if ( args->sample_list )
+    {
+        smpl = hts_readlist(args->sample_list, args->sample_is_file, &nsmpl);
+        if ( !smpl ) error("Could not parse %s\n", args->sample_list);
+        for (i=0; i<nsmpl; i++)
+        {
+            bcf_hdr_add_sample(args->header, smpl[i]);
+            free(smpl[i]);
+        }
+        free(smpl);
+        bcf_hdr_add_sample(args->header, NULL);
+        args->gts = (int32_t *) malloc(sizeof(int32_t)*nsmpl*2);
+    }
+
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+    if ( bcf_hdr_write(out_fh,args->header)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,args->header,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+
+    tsv_t *tsv = tsv_init(args->columns ? args->columns : "ID,CHROM,POS,AA");
+    if ( tsv_register(tsv, "CHROM", tsv_setter_chrom, args->header) < 0 ) error("Expected CHROM column\n");
+    if ( tsv_register(tsv, "POS", tsv_setter_pos, NULL) < 0 ) error("Expected POS column\n");
+    if ( tsv_register(tsv, "ID", tsv_setter_id, args->header) < 0 && !args->columns ) error("Expected ID column\n");
+    if ( tsv_register(tsv, "AA", tsv_setter_aa, args) < 0 )
+    {
+        if ( args->sample_list ) error("Expected AA column with -s/-S\n");
+        if ( tsv_register(tsv, "REF", tsv_setter_ref, args) < 0 || tsv_register(tsv, "ALT", tsv_setter_alt, args) < 0 )
+            error("Expected REF and ALT columns when AA was not given\n");
+    }
+
+    bcf1_t *rec = bcf_init();
+    bcf_float_set_missing(rec->qual);
+
+    kstring_t line = {0,0,0};
+    htsFile *in_fh = hts_open(args->infname, "r");
+    if ( !in_fh ) error("Could not read: %s\n", args->infname);
+    while ( hts_getline(in_fh, KS_SEP_LINE, &line) > 0 )
+    {
+        if ( line.s[0]=='#' ) continue;     // skip comments
+        bcf_clear(rec);
+
+        args->n.total++;
+        if ( !tsv_parse(tsv, rec, line.s) )
+        {
+            if ( bcf_write(out_fh, args->header, rec)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+            args->n.written++;
+        }
+        else
+            args->n.skipped++;
+    }
+    if ( hts_close(in_fh) ) error("Close failed: %s\n", args->infname);
+    free(line.s);
+
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    bcf_hdr_destroy(args->header);
+    if ( hts_close(out_fh)!=0 ) error("[%s] Error: close failed .. %s\n", __func__,args->outfname);
+    tsv_destroy(tsv);
+    bcf_destroy(rec);
+    free(args->str.s);
+    free(args->gts);
+    free(args->tsv.ref.s);
+    free(args->tsv.alt.s);
+    free(args->tsv.refalt.s);
+
+    fprintf(stderr,"Rows total: \t%d\n", args->n.total);
+    fprintf(stderr,"Rows skipped: \t%d\n", args->n.skipped);
+    fprintf(stderr,"Sites written: \t%d\n", args->n.written);
+    if ( args->sample_list )
+    {
+        fprintf(stderr,"Missing GTs: \t%d\n", args->n.missing);
+        fprintf(stderr,"Hom RR: \t%d\n", args->n.hom_rr);
+        fprintf(stderr,"Het RA: \t%d\n", args->n.het_ra);
+        fprintf(stderr,"Hom AA: \t%d\n", args->n.hom_aa);
+        fprintf(stderr,"Het AA: \t%d\n", args->n.het_aa);
+    }
+}
+
+static void vcf_to_vcf(args_t *args)
+{
+    open_vcf(args,NULL);
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+
+    bcf_hdr_t *hdr = bcf_sr_get_header(args->files,0);
+    if ( bcf_hdr_write(out_fh,hdr)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,args->header,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+
+    while ( bcf_sr_next_line(args->files) )
+    {
+        bcf1_t *line = bcf_sr_get_line(args->files,0);
+        if ( args->filter )
+        {
+            int pass = filter_test(args->filter, line, NULL);
+            if ( args->filter_logic & FLT_EXCLUDE ) pass = pass ? 0 : 1;
+            if ( !pass ) continue;
+        }
+        if ( bcf_write(out_fh,hdr,line)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+    }
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out_fh)!=0 ) error("[%s] Error: close failed .. %s\n", __func__,args->outfname);
+}
+
+static void gvcf_to_vcf(args_t *args)
+{
+    if ( !args->ref_fname ) error("--gvcf2vcf requires the --fasta-ref option\n");
+
+    args->ref = fai_load(args->ref_fname);
+    if ( !args->ref ) error("Could not load the fai index for reference %s\n", args->ref_fname);
+
+    open_vcf(args,NULL);
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->outfname,args->clevel);
+    htsFile *out_fh = hts_open(args->outfname ? args->outfname : "-", wmode);
+    if ( out_fh == NULL ) error("Can't write to \"%s\": %s\n", args->outfname, strerror(errno));
+    if ( args->n_threads ) hts_set_threads(out_fh, args->n_threads);
+
+    bcf_hdr_t *hdr = bcf_sr_get_header(args->files,0);
+    if (args->record_cmd_line) bcf_hdr_append_version(hdr, args->argc, args->argv, "bcftools_convert");
+    if ( bcf_hdr_write(out_fh,hdr)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+    if ( args->write_index && init_index(out_fh,hdr,args->outfname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->outfname);
+
+    int32_t *itmp = NULL, nitmp = 0;
+
+    while ( bcf_sr_next_line(args->files) )
+    {
+        bcf1_t *line = bcf_sr_get_line(args->files,0);
+        if ( args->filter )
+        {
+            int pass = filter_test(args->filter, line, NULL);
+            if ( args->filter_logic & FLT_EXCLUDE ) pass = pass ? 0 : 1;
+            if ( !pass )
+            {
+                if ( bcf_write(out_fh,hdr,line)!=0  ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+                continue;
+            }
+        }
+
+        // check if alleles compatible with being a gVCF record
+        // ALT must be one of ., <*>, <X>, <NON_REF>
+        // check for INFO/END is below
+        int i, gallele = -1;
+        if (line->n_allele==1)
+            gallele = 0; // illumina/bcftools-call gvcf (if INFO/END present)
+        else if ( line->d.allele[1][0]=='<' )
+        {
+            for (i=1; i<line->n_allele; i++)
+            {
+                if ( line->d.allele[i][1]=='*' && line->d.allele[i][2]=='>' && line->d.allele[i][3]=='\0' ) { gallele = i; break; } // mpileup/spec compliant gVCF
+                if ( line->d.allele[i][1]=='X' && line->d.allele[i][2]=='>' && line->d.allele[i][3]=='\0' ) { gallele = i; break; } // old mpileup gVCF
+                if ( strcmp(line->d.allele[i],"<NON_REF>")==0 ) { gallele = i; break; }               // GATK gVCF
+            }
+        }
+
+        // no gVCF compatible alleles
+        if (gallele<0)
+        {
+            if ( bcf_write(out_fh,hdr,line)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+            continue;
+        }
+
+        int nend = bcf_get_info_int32(hdr,line,"END",&itmp,&nitmp);
+        if ( nend!=1 )
+        {
+            // No INFO/END => not gVCF record
+            if ( bcf_write(out_fh,hdr,line)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+            continue;
+        }
+        bcf_update_info_int32(hdr,line,"END",NULL,0);
+        int pos, len;
+        for (pos=line->pos; pos<itmp[0]; pos++)
+        {
+            line->pos = pos;
+            char *ref = faidx_fetch_seq(args->ref, (char*)bcf_hdr_id2name(hdr,line->rid), line->pos, line->pos, &len);
+            if ( !ref ) error("faidx_fetch_seq failed at %s:%"PRId64"\n", bcf_hdr_id2name(hdr,line->rid),(int64_t) line->pos+1);
+            strncpy(line->d.allele[0],ref,len);
+            if ( bcf_write(out_fh,hdr,line)!=0 ) error("[%s] Error: cannot write to %s\n", __func__,args->outfname);
+            free(ref);
+        }
+    }
+    free(itmp);
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out_fh)<0 )
+        {
+            if ( hts_close(out_fh) ) error("Close failed: %s\n", args->outfname);
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out_fh)!=0 ) error("[%s] Error: close failed .. %s\n", __func__,args->outfname);
+}
+
+static void usage(void)
+{
+    fprintf(stderr, "\n");
+    fprintf(stderr, "About:   Converts VCF/BCF to other formats and back. See man page for file\n");
+    fprintf(stderr, "         formats details. When specifying output files explicitly instead\n");
+    fprintf(stderr, "         of with PREFIX, one can use '-' for stdout and '.' to suppress.\n");
+    fprintf(stderr, "Usage:   bcftools convert [OPTIONS] INPUT_FILE\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "VCF input options:\n");
+    fprintf(stderr, "   -e, --exclude EXPR             Exclude sites for which the expression is true\n");
+    fprintf(stderr, "   -i, --include EXPR             Select sites for which the expression is true\n");
+    fprintf(stderr, "   -r, --regions REGION           Restrict to comma-separated list of regions\n");
+    fprintf(stderr, "   -R, --regions-file FILE        Restrict to regions listed in a file\n");
+    fprintf(stderr, "       --regions-overlap 0|1|2    Include if POS in the region (0), record overlaps (1), variant overlaps (2) [1]\n");
+    fprintf(stderr, "   -s, --samples LIST             List of samples to include\n");
+    fprintf(stderr, "   -S, --samples-file FILE        File of samples to include\n");
+    fprintf(stderr, "   -t, --targets REGION           Similar to -r but streams rather than index-jumps\n");
+    fprintf(stderr, "   -T, --targets-file FILE        Similar to -R but streams rather than index-jumps\n");
+    fprintf(stderr, "       --targets-overlap 0|1|2    Include if POS in the region (0), record overlaps (1), variant overlaps (2) [0]\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "VCF output options:\n");
+    fprintf(stderr, "       --no-version               Do not append version and command line to the header\n");
+    fprintf(stderr, "   -o, --output FILE              Output file name [stdout]\n");
+    fprintf(stderr, "   -O, --output-type u|b|v|z[0-9] u/b: un/compressed BCF, v/z: un/compressed VCF, 0-9: compression level [v]\n");
+    fprintf(stderr, "       --threads INT              Use multithreading with INT worker threads [0]\n");
+    fprintf(stderr, "       --write-index              Automatically index the output files [off]\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "GEN/SAMPLE conversion (input/output from IMPUTE2):\n");
+    fprintf(stderr, "   -G, --gensample2vcf ...        <PREFIX>|<GEN-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "   -g, --gensample ...            <PREFIX>|<GEN-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "       --3N6                      Use 3*N+6 column format instead of the old 3*N+5 column format\n");
+    fprintf(stderr, "       --tag STRING               Tag to take values for .gen file: GT,PL,GL,GP [GT]\n");
+    fprintf(stderr, "       --chrom                    Output chromosome in first column instead of CHROM:POS_REF_ALT\n");
+    fprintf(stderr, "       --keep-duplicates          Keep duplicate positions\n");
+    fprintf(stderr, "       --sex FILE                 Output sex column in the sample-file, input format is: Sample\\t[MF]\n");
+    fprintf(stderr, "       --vcf-ids                  Output VCF IDs in second column instead of CHROM:POS_REF_ALT\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "gVCF conversion:\n");
+    fprintf(stderr, "       --gvcf2vcf                 Expand gVCF reference blocks\n");
+    fprintf(stderr, "   -f, --fasta-ref FILE           Reference sequence in fasta format\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "HAP/SAMPLE conversion (output from SHAPEIT):\n");
+    fprintf(stderr, "       --hapsample2vcf ...        <PREFIX>|<HAP-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "       --hapsample ...            <PREFIX>|<HAP-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "       --haploid2diploid          Convert haploid genotypes to diploid homozygotes\n");
+    fprintf(stderr, "       --sex FILE                 Output sex column in the sample-file, input format is: Sample\\t[MF]\n");
+    fprintf(stderr, "       --vcf-ids                  Output VCF IDs instead of CHROM:POS_REF_ALT\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "HAP/LEGEND/SAMPLE conversion:\n");
+    fprintf(stderr, "   -H, --haplegendsample2vcf ...  <PREFIX>|<HAP-FILE>,<LEGEND-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "   -h, --haplegendsample ...      <PREFIX>|<HAP-FILE>,<LEGEND-FILE>,<SAMPLE-FILE>\n");
+    fprintf(stderr, "       --haploid2diploid          Convert haploid genotypes to diploid homozygotes\n");
+    fprintf(stderr, "       --sex FILE                 Output sex column in the sample-file, input format is: Sample\\t[MF]\n");
+    fprintf(stderr, "       --vcf-ids                  Output VCF IDs instead of CHROM:POS_REF_ALT\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "TSV conversion:\n");
+    fprintf(stderr, "       --tsv2vcf FILE\n");
+    fprintf(stderr, "   -c, --columns STRING           Columns of the input tsv file, see man page for details [ID,CHROM,POS,AA]\n");
+    fprintf(stderr, "   -f, --fasta-ref FILE           Reference sequence in fasta format\n");
+    fprintf(stderr, "   -s, --samples LIST             List of sample names\n");
+    fprintf(stderr, "   -S, --samples-file FILE        File of sample names\n");
+    fprintf(stderr, "\n");
+    // fprintf(stderr, "PLINK options:\n");
+    // fprintf(stderr, "   -p, --plink <prefix>|<ped>,<map>,<fam>|<bed>,<bim>,<fam>|<tped>,<tfam>\n");
+    // fprintf(stderr, "       --tped              make tped file instead\n");
+    // fprintf(stderr, "       --bin               make binary bed/fam/bim files\n");
+    // fprintf(stderr, "\n");
+    // fprintf(stderr, "PBWT options:\n");
+    // fprintf(stderr, "   -b, --pbwt          <prefix> or <pbwt>,<sites>,<sample>,<missing>\n");
+    // fprintf(stderr, "\n");
+    exit(1);
+}
+
+int main_vcfconvert(int argc, char *argv[])
+{
+    int c;
+    args_t *args = (args_t*) calloc(1,sizeof(args_t));
+    args->argc   = argc; args->argv = argv;
+    args->outfname = "-";
+    args->output_type = FT_VCF;
+    args->n_threads = 0;
+    args->record_cmd_line = 1;
+    args->regions_overlap = 1;
+    args->targets_overlap = 0;
+    args->clevel = -1;
+
+    static struct option loptions[] =
+    {
+        {"include",required_argument,NULL,'i'},
+        {"exclude",required_argument,NULL,'e'},
+        {"output",required_argument,NULL,'o'},
+        {"output-type",required_argument,NULL,'O'},
+        {"threads",required_argument,NULL,9},
+        {"regions",required_argument,NULL,'r'},
+        {"regions-file",required_argument,NULL,'R'},
+        {"regions-overlap",required_argument,NULL,13},
+        {"targets",required_argument,NULL,'t'},
+        {"targets-file",required_argument,NULL,'T'},
+        {"targets-overlap",required_argument,NULL,14},
+        {"samples",required_argument,NULL,'s'},
+        {"samples-file",required_argument,NULL,'S'},
+        {"sex",required_argument,NULL,11},
+        {"gensample",required_argument,NULL,'g'},
+        {"gensample2vcf",required_argument,NULL,'G'},
+        {"tag",required_argument,NULL,1},
+        {"chrom",no_argument,NULL,8},
+        {"3N6",no_argument,NULL,15},
+        {"tsv2vcf",required_argument,NULL,2},
+        {"hapsample",required_argument,NULL,7},
+        {"hapsample2vcf",required_argument,NULL,3},
+        {"vcf-ids",no_argument,NULL,4},
+        {"haploid2diploid",no_argument,NULL,5},
+        {"gvcf2vcf",no_argument,NULL,6},
+        {"haplegendsample",required_argument,NULL,'h'},
+        {"haplegendsample2vcf",required_argument,NULL,'H'},
+        {"columns",required_argument,NULL,'c'},
+        {"fasta-ref",required_argument,NULL,'f'},
+        {"no-version",no_argument,NULL,10},
+        {"keep-duplicates",no_argument,NULL,12},
+        {"write-index",no_argument,NULL,16},
+        {NULL,0,NULL,0}
+    };
+    char *tmp;
+    while ((c = getopt_long(argc, argv, "?h:r:R:s:S:t:T:i:e:g:G:o:O:c:f:H:",loptions,NULL)) >= 0) {
+        switch (c) {
+            case 'e':
+                if ( args->filter_str ) error("Error: only one -i or -e expression can be given, and they cannot be combined\n");
+                args->filter_str = optarg; args->filter_logic |= FLT_EXCLUDE; break;
+            case 'i':
+                if ( args->filter_str ) error("Error: only one -i or -e expression can be given, and they cannot be combined\n");
+                args->filter_str = optarg; args->filter_logic |= FLT_INCLUDE; break;
+            case 'r': args->regions_list = optarg; break;
+            case 'R': args->regions_list = optarg; args->regions_is_file = 1; break;
+            case 't': args->targets_list = optarg; break;
+            case 'T': args->targets_list = optarg; args->targets_is_file = 1; break;
+            case 's': args->sample_list = optarg; break;
+            case 'S': args->sample_list = optarg; args->sample_is_file = 1; break;
+            case 'g': args->convert_func = vcf_to_gensample; args->outfname = optarg; break;
+            case 'G': args->convert_func = gensample_to_vcf; args->infname = optarg; break;
+            case  1 : args->tag = optarg; break;
+            case  2 : args->convert_func = tsv_to_vcf; args->infname = optarg; break;
+            case  3 : args->convert_func = hapsample_to_vcf; args->infname = optarg; break;
+            case  4 : args->output_vcf_ids = 1; break;
+            case  5 : args->hap2dip = 1; break;
+            case  6 : args->convert_func = gvcf_to_vcf; break;
+            case  7 : args->convert_func = vcf_to_hapsample; args->outfname = optarg; break;
+            case  8 : error("The --chrom option has been deprecated, please use --3N6 instead\n"); break;
+            case 15 : args->gen_3N6 = 1; break;
+            case 16 : args->write_index = 1; break;
+            case 'H': args->convert_func = haplegendsample_to_vcf; args->infname = optarg; break;
+            case 'f': args->ref_fname = optarg; break;
+            case 'c': args->columns = optarg; break;
+            case 'o': args->outfname = optarg; break;
+            case 'O':
+                switch (optarg[0]) {
+                    case 'b': args->output_type = FT_BCF_GZ; break;
+                    case 'u': args->output_type = FT_BCF; break;
+                    case 'z': args->output_type = FT_VCF_GZ; break;
+                    case 'v': args->output_type = FT_VCF; break;
+                    default:
+                    {
+                        args->clevel = strtol(optarg,&tmp,10);
+                        if ( *tmp || args->clevel<0 || args->clevel>9 ) error("The output type \"%s\" not recognised\n", optarg);
+                    }
+                }
+                if ( optarg[1] )
+                {
+                    args->clevel = strtol(optarg+1,&tmp,10);
+                    if ( *tmp || args->clevel<0 || args->clevel>9 ) error("Could not parse argument: --compression-level %s\n", optarg+1);
+                }
+                break;
+            case 'h': args->convert_func = vcf_to_haplegendsample; args->outfname = optarg; break;
+            case  9 : args->n_threads = strtol(optarg, 0, 0); break;
+            case 10 : args->record_cmd_line = 0; break;
+            case 11 : args->sex_fname = optarg; break;
+            case 12 : args->keep_duplicates = 1; break;
+            case 13 :
+                args->regions_overlap = parse_overlap_option(optarg);
+                if ( args->regions_overlap < 0 ) error("Could not parse: --regions-overlap %s\n",optarg);
+                break;
+            case 14 :
+                args->targets_overlap = parse_overlap_option(optarg);
+                if ( args->targets_overlap < 0 ) error("Could not parse: --targets-overlap %s\n",optarg);
+                break;
+            case '?': usage(); break;
+            default: error("Unknown argument: %s\n", optarg);
+        }
+    }
+
+    if ( !args->infname )
+    {
+        if ( optind>=argc )
+        {
+            if ( !isatty(fileno((FILE *)stdin)) ) args->infname = "-";
+        }
+        else args->infname = argv[optind];
+    }
+    if ( !args->infname ) usage();
+
+    if ( args->convert_func ) args->convert_func(args);
+    else vcf_to_vcf(args);
+
+    destroy_data(args);
+    free(args);
+    return 0;
+}

falcon/lib/python3.10/site-packages/pysam/include/bcftools/vcfgtcheck.c.pysam.c

@@ -0,0 +1,1286 @@
+#include "bcftools.pysam.h"
+
+/*  vcfgtcheck.c -- Check sample identity.
+
+    Copyright (C) 2013-2023 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <assert.h>
+#include <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <math.h>
+#include <htslib/vcf.h>
+#include <htslib/synced_bcf_reader.h>
+#include <htslib/vcfutils.h>
+#include <htslib/kbitset.h>
+#include <htslib/hts_os.h>
+#include <inttypes.h>
+#include <sys/time.h>
+#include "bcftools.h"
+#include "extsort.h"
+//#include "hclust.h"
+
+typedef struct
+{
+    int iqry, igt;
+}
+pair_t;
+
+typedef struct
+{
+    bcf_srs_t *files;           // first reader is the query VCF - single sample normally or multi-sample for cross-check
+    bcf_hdr_t *gt_hdr, *qry_hdr; // VCF with genotypes to compare against and the query VCF
+    char *cwd, **argv, *gt_samples, *qry_samples, *regions, *targets, *qry_fname, *gt_fname, *pair_samples;
+    int argc, gt_samples_is_file, qry_samples_is_file, regions_is_file, targets_is_file, pair_samples_is_file;
+    int regions_overlap, targets_overlap;
+    int qry_use_GT,gt_use_GT, nqry_smpl,ngt_smpl, *qry_smpl,*gt_smpl;
+    int nused[2][2];
+    double *pdiff, *qry_prob, *gt_prob;
+    uint32_t *ndiff,*ncnt,ncmp, npairs;
+    int32_t *qry_arr,*gt_arr, nqry_arr,ngt_arr;
+    uint8_t *qry_dsg, *gt_dsg;
+    pair_t *pairs;
+    double *hwe_prob, dsg2prob[8][3], pl2prob[256];
+    double min_inter_err, max_intra_err;
+    int all_sites, hom_only, ntop, cross_check, calc_hwe_prob, sort_by_hwe, dry_run, use_PLs;
+    FILE *fp;
+    unsigned int nskip_no_match, nskip_not_ba, nskip_mono, nskip_no_data, nskip_dip_GT, nskip_dip_PL;
+
+    // for --distinctive-sites
+    double distinctive_sites;
+    kbitset_t *kbs_diff;
+    size_t diff_sites_size;
+    extsort_t *es;
+    char *es_tmp_prefix, *es_max_mem;
+}
+args_t;
+
+static void set_cwd(args_t *args)
+{
+    int i;
+    char *buf;
+    size_t nbuf = 500;
+    args->cwd = (char*) malloc(sizeof(char)*nbuf);
+    for (i=0; i<5; i++)
+    {
+        if ( (buf = getcwd(args->cwd, nbuf)) ) break;
+        nbuf *= 2;
+        args->cwd = (char*) realloc(args->cwd, sizeof(char)*nbuf);
+    }
+    assert(buf);
+}
+static void print_header(args_t *args, FILE *fp)
+{
+    fprintf(fp, "# This file was produced by bcftools (%s+htslib-%s), the command line was:\n", bcftools_version(), hts_version());
+    fprintf(fp, "# \t bcftools %s ", args->argv[0]);
+    int i;
+    for (i=1; i<args->argc; i++)
+        fprintf(fp, " %s",args->argv[i]);
+    fprintf(fp, "\n# and the working directory was:\n");
+    fprintf(fp, "# \t %s\n#\n", args->cwd);
+}
+
+static int cmp_int(const void *_a, const void *_b)
+{
+    int a = *((int*)_a);
+    int b = *((int*)_b);
+    if ( a < b ) return -1;
+    if ( a > b ) return 1;
+    return 0;
+}
+static int cmp_pair(const void *_a, const void *_b)
+{
+    pair_t *a = (pair_t*)_a;
+    pair_t *b = (pair_t*)_b;
+    if ( a->iqry < b->iqry ) return -1;
+    if ( a->iqry > b->iqry ) return 1;
+    if ( a->igt < b->igt ) return -1;
+    if ( a->igt > b->igt ) return 1;
+    return 0;
+}
+
+typedef struct
+{
+    uint32_t ndiff,rid,pos,rand; // rand is to shuffle sites with the same ndiff from across all chromosoms
+    unsigned long kbs_dat[1];
+}
+diff_sites_t;
+#if DBG
+static void diff_sites_debug_print(args_t *args, diff_sites_t *ds)
+{
+    int i;
+    memcpy(args->kbs_diff->b,ds->kbs_dat,args->kbs_diff->n*sizeof(unsigned long));
+    fprintf(bcftools_stderr,"%s:%d\t%d\t",bcf_hdr_id2name(args->qry_hdr,ds->rid),ds->pos+1,ds->ndiff);
+    for (i=0; i<args->npairs; i++) fprintf(bcftools_stderr,"%d",kbs_exists(args->kbs_diff,i)?1:0);
+    fprintf(bcftools_stderr,"\n");
+}
+#endif
+static int diff_sites_cmp(const void *aptr, const void *bptr)
+{
+    diff_sites_t *a = *((diff_sites_t**)aptr);
+    diff_sites_t *b = *((diff_sites_t**)bptr);
+    if ( a->ndiff < b->ndiff ) return 1;        // descending order
+    if ( a->ndiff > b->ndiff ) return -1;
+    if ( a->rand < b->rand ) return -1;
+    if ( a->rand > b->rand ) return 1;
+    return 0;
+}
+static void diff_sites_init(args_t *args)
+{
+    int nsites = args->distinctive_sites<=1 ? args->npairs*args->distinctive_sites : args->distinctive_sites;
+    if ( nsites<=0 ) error("The value for --distinctive-sites was set too low: %d\n",nsites);
+    if ( nsites > args->npairs )
+    {
+        fprintf(bcftools_stderr,"Warning: The value for --distinctive-sites is bigger than is the number of pairs, all discordant sites be printed.\n");
+        nsites = args->npairs;
+        args->distinctive_sites = args->npairs + 1;
+    }
+    else
+        args->distinctive_sites = nsites;
+    args->kbs_diff = kbs_init(args->npairs);
+    size_t n = (args->npairs + KBS_ELTBITS-1) / KBS_ELTBITS;
+    assert( n==args->kbs_diff->n );
+    args->diff_sites_size = sizeof(diff_sites_t) + (n-1)*sizeof(unsigned long);
+    args->es = extsort_alloc();
+    extsort_set_opt(args->es,size_t,DAT_SIZE,args->diff_sites_size);
+    extsort_set_opt(args->es,const char*,TMP_PREFIX,args->es_tmp_prefix);
+    extsort_set_opt(args->es,const char*,MAX_MEM,args->es_max_mem);
+    extsort_set_opt(args->es,extsort_cmp_f,FUNC_CMP,diff_sites_cmp);
+    extsort_init(args->es);
+}
+static void diff_sites_destroy(args_t *args)
+{
+    kbs_destroy(args->kbs_diff);
+    extsort_destroy(args->es);
+}
+static inline void diff_sites_reset(args_t *args)
+{
+    kbs_clear(args->kbs_diff);
+}
+static inline void diff_sites_push(args_t *args, int ndiff, int rid, int pos)
+{
+    diff_sites_t *dat = (diff_sites_t*) malloc(args->diff_sites_size);
+    memset(dat,0,sizeof(*dat)); // for debugging: prevent warnings about uninitialized memory coming from struct padding (not needed after rand added)
+    dat->ndiff = ndiff;
+    dat->rid  = rid;
+    dat->pos  = pos;
+    dat->rand = hts_lrand48();
+    memcpy(dat->kbs_dat,args->kbs_diff->b,args->kbs_diff->n*sizeof(unsigned long));
+    extsort_push(args->es,dat);
+}
+static inline int diff_sites_shift(args_t *args, int *ndiff, int *rid, int *pos)
+{
+    diff_sites_t *dat = (diff_sites_t*) extsort_shift(args->es);
+    if ( !dat ) return 0;
+    *ndiff = dat->ndiff;
+    *rid   = dat->rid;
+    *pos   = dat->pos;
+    memcpy(args->kbs_diff->b,dat->kbs_dat,args->kbs_diff->n*sizeof(unsigned long));
+    return 1;
+}
+
+static void init_samples(char *list, int list_is_file, int **smpl, int *nsmpl, bcf_hdr_t *hdr, char *vcf_fname)
+{
+    int i;
+    if ( !strcmp(list,"-") )
+    {
+        *nsmpl = bcf_hdr_nsamples(hdr);
+        *smpl  = (int*) malloc(sizeof(**smpl)*(*nsmpl));
+        for (i=0; i<*nsmpl; i++) (*smpl)[i] = i;
+        return;
+    }
+
+    char **tmp = hts_readlist(list, list_is_file, nsmpl);
+    if ( !tmp || !*nsmpl ) error("Failed to parse %s\n", list);
+    *smpl = (int*) malloc(sizeof(**smpl)*(*nsmpl));
+    for (i=0; i<*nsmpl; i++)
+    {
+        int idx = bcf_hdr_id2int(hdr, BCF_DT_SAMPLE, tmp[i]);
+        if ( idx<0 ) error("No such sample in %s: [%s]\n",vcf_fname,tmp[i]);
+        (*smpl)[i] = idx;
+        free(tmp[i]);
+    }
+    free(tmp);
+    qsort(*smpl,*nsmpl,sizeof(**smpl),cmp_int);
+    // check for duplicates
+    for (i=1; i<*nsmpl; i++)
+        if ( (*smpl)[i-1]==(*smpl)[i] )
+            error("Error: the sample \"%s\" is listed twice in %s\n", hdr->samples[(*smpl)[i]],list);
+}
+
+static void init_data(args_t *args)
+{
+    hts_srand48(0);
+
+    args->files = bcf_sr_init();
+    if ( args->regions )
+    {
+        bcf_sr_set_opt(args->files,BCF_SR_REGIONS_OVERLAP,args->regions_overlap);
+        if ( bcf_sr_set_regions(args->files, args->regions, args->regions_is_file)<0 ) error("Failed to read the regions: %s\n", args->regions);
+    }
+    if ( args->targets )
+    {
+        bcf_sr_set_opt(args->files,BCF_SR_TARGETS_OVERLAP,args->targets_overlap);
+        if ( bcf_sr_set_targets(args->files, args->targets, args->targets_is_file, 0)<0 ) error("Failed to read the targets: %s\n", args->targets);
+    }
+
+    if ( args->gt_fname ) bcf_sr_set_opt(args->files, BCF_SR_REQUIRE_IDX);
+    if ( !bcf_sr_add_reader(args->files,args->qry_fname) ) error("Failed to open %s: %s\n", args->qry_fname,bcf_sr_strerror(args->files->errnum));
+    if ( args->gt_fname && !bcf_sr_add_reader(args->files, args->gt_fname) )
+        error("Failed to read from %s: %s\n", !strcmp("-",args->gt_fname)?"standard input":args->gt_fname,bcf_sr_strerror(args->files->errnum));
+
+    args->qry_hdr = bcf_sr_get_header(args->files,0);
+    if ( !bcf_hdr_nsamples(args->qry_hdr) ) error("No samples in %s?\n", args->qry_fname);
+    if ( args->gt_fname )
+    {
+        args->gt_hdr = bcf_sr_get_header(args->files,1);
+        if ( !bcf_hdr_nsamples(args->gt_hdr) ) error("No samples in %s?\n", args->gt_fname);
+    }
+
+    // Determine whether GT or PL will be used
+    if ( args->qry_use_GT==-1 ) // not set by -u, qry uses PL by default
+    {
+        if ( bcf_hdr_id2int(args->qry_hdr,BCF_DT_ID,"PL")>=0 )
+            args->qry_use_GT = 0;
+        else if ( bcf_hdr_id2int(args->qry_hdr,BCF_DT_ID,"GT")>=0 )
+            args->qry_use_GT = 1;
+        else
+            error("[E::%s] Neither PL nor GT tag is present in the header of %s\n", __func__, args->qry_fname);
+    }
+    else if ( args->qry_use_GT==1 )
+    {
+        if ( bcf_hdr_id2int(args->qry_hdr,BCF_DT_ID,"GT")<0 )
+            error("[E::%s] The GT tag is not present in the header of %s\n", __func__, args->qry_fname);
+    }
+    else if ( bcf_hdr_id2int(args->qry_hdr,BCF_DT_ID,"PL")<0 )
+        error("[E::%s] The PL tag is not present in the header of %s\n", __func__, args->qry_fname);
+
+    if ( args->gt_hdr )
+    {
+        if ( args->gt_use_GT==-1 ) // not set by -u, gt uses GT by default
+        {
+            if ( bcf_hdr_id2int(args->gt_hdr,BCF_DT_ID,"GT")>=0 )
+                args->gt_use_GT = 1;
+            else if ( bcf_hdr_id2int(args->gt_hdr,BCF_DT_ID,"PL")>=0 )
+                args->gt_use_GT = 0;
+            else
+                error("[E::%s] Neither PL nor GT tag is present in the header of %s\n", __func__, args->gt_fname);
+        }
+        else if ( args->gt_use_GT==1 )
+        {
+            if ( bcf_hdr_id2int(args->gt_hdr,BCF_DT_ID,"GT")<0 )
+                error("[E::%s] The GT tag is not present in the header of %s\n", __func__, args->gt_fname);
+        }
+        else if ( bcf_hdr_id2int(args->gt_hdr,BCF_DT_ID,"PL")<0 )
+            error("[E::%s] The PL tag is not present in the header of %s\n", __func__, args->gt_fname);
+    }
+    else
+        args->gt_use_GT = args->qry_use_GT;
+
+    // Prepare samples
+    int i,j;
+    args->nqry_smpl = bcf_hdr_nsamples(args->qry_hdr);
+    if ( args->qry_samples )
+    {
+        init_samples(args->qry_samples, args->qry_samples_is_file, &args->qry_smpl, &args->nqry_smpl, args->qry_hdr, args->qry_fname);
+    }
+    if ( args->gt_samples )
+    {
+        init_samples(args->gt_samples, args->gt_samples_is_file, &args->gt_smpl, &args->ngt_smpl,
+            args->gt_hdr ? args->gt_hdr : args->qry_hdr,
+            args->gt_fname ? args->gt_fname : args->qry_fname);
+    }
+    else if ( args->pair_samples )
+    {
+        int npairs;
+        char **tmp = hts_readlist(args->pair_samples, args->pair_samples_is_file, &npairs);
+        if ( !tmp || !npairs ) error("Failed to parse %s\n", args->pair_samples);
+        if ( !args->pair_samples_is_file && npairs%2 ) error("Expected even number of comma-delimited samples with -p\n");
+        args->npairs = args->pair_samples_is_file ? npairs : npairs/2;
+        args->pairs  = (pair_t*) calloc(args->npairs,sizeof(*args->pairs));
+        if ( !args->pair_samples_is_file )
+        {
+            for (i=0; i<args->npairs; i++)
+            {
+                args->pairs[i].iqry = bcf_hdr_id2int(args->qry_hdr, BCF_DT_SAMPLE, tmp[2*i]);
+                args->pairs[i].igt  = bcf_hdr_id2int(args->gt_hdr?args->gt_hdr:args->qry_hdr, BCF_DT_SAMPLE, tmp[2*i+1]);
+                if ( args->pairs[i].iqry < 0 ) error("No such sample in %s: [%s]\n",args->qry_fname,tmp[2*i]);
+                if ( args->pairs[i].igt  < 0 ) error("No such sample in %s: [%s]\n",args->gt_fname?args->gt_fname:args->qry_fname,tmp[2*i+1]);
+                free(tmp[2*i]);
+                free(tmp[2*i+1]);
+            }
+        }
+        else
+        {
+            for (i=0; i<args->npairs; i++)
+            {
+                char *ptr = tmp[i];
+                while ( *ptr && !isspace(*ptr) ) ptr++;
+                if ( !*ptr ) error("Could not parse %s: %s\n",args->pair_samples,tmp[i]);
+                *ptr = 0;
+                args->pairs[i].iqry = bcf_hdr_id2int(args->qry_hdr, BCF_DT_SAMPLE, tmp[i]);
+                if ( args->pairs[i].iqry < 0 ) error("No such sample in %s: [%s]\n",args->qry_fname,tmp[i]);
+                ptr++;
+                while ( *ptr && isspace(*ptr) ) ptr++;
+                args->pairs[i].igt = bcf_hdr_id2int(args->gt_hdr?args->gt_hdr:args->qry_hdr, BCF_DT_SAMPLE, ptr);
+                if ( args->pairs[i].igt < 0 ) error("No such sample in %s: [%s]\n",args->gt_fname?args->gt_fname:args->qry_fname,ptr);
+                free(tmp[i]);
+            }
+        }
+        free(tmp);
+        qsort(args->pairs,args->npairs,sizeof(*args->pairs),cmp_pair);
+    }
+    else if ( args->gt_hdr )
+        args->ngt_smpl = bcf_hdr_nsamples(args->gt_hdr);
+    if ( !args->ngt_smpl )
+    {
+        args->ngt_smpl = args->nqry_smpl;
+        args->gt_smpl  = args->qry_smpl;
+        args->cross_check = 1;
+    }
+
+    // The data arrays
+    if ( !args->npairs ) args->npairs = args->cross_check ? args->nqry_smpl*(args->nqry_smpl+1)/2 : args->ngt_smpl*args->nqry_smpl;
+    if ( !args->pair_samples )
+    {
+        args->qry_dsg = (uint8_t*) malloc(args->nqry_smpl);
+        args->gt_dsg  = args->cross_check ? args->qry_dsg : (uint8_t*) malloc(args->ngt_smpl);
+    }
+    if ( args->use_PLs )
+    {
+        args->pdiff = (double*) calloc(args->npairs,sizeof(*args->pdiff));      // log probability of pair samples being the same
+        args->qry_prob = (double*) malloc(3*args->nqry_smpl*sizeof(*args->qry_prob));
+        args->gt_prob  = args->cross_check ? args->qry_prob : (double*) malloc(3*args->ngt_smpl*sizeof(*args->gt_prob));
+
+        // dsg2prob: the first index is bitmask of 8 possible dsg combinations (only 1<<0,1<<2,1<<3 are set, accessing
+        // anything else indicated an error, this is just to reuse gt_to_dsg()); the second index are the corresponding
+        // probabilities of 0/0, 0/1, and 1/1 genotypes
+        for (i=0; i<8; i++)
+            for (j=0; j<3; j++)
+                args->dsg2prob[i][j] = HUGE_VAL;
+        args->dsg2prob[1][0] = -log(1-pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[1][1] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[1][2] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[2][0] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[2][1] = -log(1-pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[2][2] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[4][0] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[4][1] = -log(0.5*pow(10,-0.1*args->use_PLs));
+        args->dsg2prob[4][2] = -log(1-pow(10,-0.1*args->use_PLs));
+
+        // lookup table to avoid exponentiation
+        for (i=0; i<256; i++) args->pl2prob[i] = pow(10,-0.1*i);
+    }
+    else
+        args->ndiff = (uint32_t*) calloc(args->npairs,sizeof(*args->ndiff));    // number of differing genotypes for each pair of samples
+    args->ncnt  = (uint32_t*) calloc(args->npairs,sizeof(*args->ncnt));         // number of comparisons performed (non-missing data)
+    if ( !args->ncnt ) error("Error: failed to allocate %.1f Mb\n", args->npairs*sizeof(*args->ncnt)/1e6);
+    if ( args->calc_hwe_prob )
+    {
+        // prob of the observed sequence of matches given site AFs and HWE
+        args->hwe_prob = (double*) calloc(args->npairs,sizeof(*args->hwe_prob));
+        if ( !args->hwe_prob ) error("Error: failed to allocate %.1f Mb. Run with --no-HWE-prob to save some memory.\n", args->npairs*sizeof(*args->hwe_prob)/1e6);
+    }
+
+    if ( args->distinctive_sites ) diff_sites_init(args);
+
+    args->fp = bcftools_stdout;
+    print_header(args, args->fp);
+}
+
+static void destroy_data(args_t *args)
+{
+    if ( args->gt_dsg!=args->qry_dsg ) free(args->gt_dsg);
+    free(args->qry_dsg);
+    if ( args->gt_prob!=args->qry_prob ) free(args->gt_prob);
+    free(args->qry_prob);
+    free(args->es_max_mem);
+    fclose(args->fp);
+    if ( args->distinctive_sites ) diff_sites_destroy(args);
+    free(args->hwe_prob);
+    free(args->cwd);
+    free(args->qry_arr);
+    if ( args->gt_hdr ) free(args->gt_arr);
+    free(args->pdiff);
+    free(args->ndiff);
+    free(args->ncnt);
+    free(args->qry_smpl);
+    if ( args->gt_smpl!=args->qry_smpl ) free(args->gt_smpl);
+    free(args->pairs);
+    bcf_sr_destroy(args->files);
+}
+
+static inline uint8_t gt_to_dsg(int32_t *ptr)
+{
+    if ( bcf_gt_is_missing(ptr[0]) || bcf_gt_is_missing(ptr[1]) || ptr[1]==bcf_int32_vector_end ) return 0;
+    uint8_t dsg = (bcf_gt_allele(ptr[0])?1:0) + (bcf_gt_allele(ptr[1])?1:0);
+    return 1<<dsg;
+}
+static inline uint8_t pl_to_dsg(int32_t *ptr)
+{
+    if ( ptr[0]==bcf_int32_missing || ptr[1]==bcf_int32_missing || ptr[2]==bcf_int32_missing ) return 0;
+    if ( ptr[1]==bcf_int32_vector_end || ptr[2]==bcf_int32_vector_end ) return 0;
+    int min_pl = ptr[0]<ptr[1] ? (ptr[0]<ptr[2]?ptr[0]:ptr[2]) : (ptr[1]<ptr[2]?ptr[1]:ptr[2]);
+    uint8_t dsg = 0;
+    if ( ptr[0]==min_pl ) dsg |= 1;
+    if ( ptr[1]==min_pl ) dsg |= 2;
+    if ( ptr[2]==min_pl ) dsg |= 4;
+    return dsg;
+}
+static inline uint8_t gt_to_prob(args_t *args, int32_t *ptr, double *prob)
+{
+    uint8_t dsg = gt_to_dsg(ptr);
+    if ( dsg )
+    {
+        prob[0] = args->dsg2prob[dsg][0];
+        prob[1] = args->dsg2prob[dsg][1];
+        prob[2] = args->dsg2prob[dsg][2];
+    }
+    return dsg;
+}
+static inline uint8_t pl_to_prob(args_t *args, int32_t *ptr, double *prob)
+{
+    uint8_t dsg = pl_to_dsg(ptr);
+    if ( dsg )
+    {
+        prob[0] = (ptr[0]>=0 && ptr[0]<255) ? args->pl2prob[ptr[0]] : args->pl2prob[255];
+        prob[1] = (ptr[1]>=0 && ptr[1]<255) ? args->pl2prob[ptr[1]] : args->pl2prob[255];
+        prob[2] = (ptr[2]>=0 && ptr[2]<255) ? args->pl2prob[ptr[2]] : args->pl2prob[255];
+        double sum = prob[0] + prob[1] + prob[2];
+        prob[0] /= sum;
+        prob[1] /= sum;
+        prob[2] /= sum;
+        prob[0] = -log(prob[0]);
+        prob[1] = -log(prob[1]);
+        prob[2] = -log(prob[2]);
+    }
+    return dsg;
+}
+static int set_data(args_t *args, bcf_hdr_t *hdr, bcf1_t *rec, int32_t **arr, int32_t *narr, int *narr1, int *use_GT)
+{
+    static int warn_dip_GT = 1;
+    static int warn_dip_PL = 1;
+    int i;
+    for (i=0; i<2; i++)
+    {
+        if ( *use_GT )
+        {
+            int ret = bcf_get_genotypes(hdr,rec,arr,narr);
+            if ( ret < 0 )
+            {
+                if ( !i ) { *use_GT = 0; continue; }
+                args->nskip_no_data++;
+                return -1;
+            }
+            if ( ret != 2*bcf_hdr_nsamples(hdr) )
+            {
+                if ( warn_dip_GT )
+                {
+                    fprintf(bcftools_stderr,"INFO: skipping %s:%"PRIhts_pos", only diploid FORMAT/GT fields supported. (This is printed only once.)\n", bcf_seqname(hdr,rec),rec->pos+1);
+                    warn_dip_GT = 0;
+                }
+                args->nskip_dip_GT++;
+                return -1;
+            }
+            *narr1 = 2;
+            return 0;
+        }
+
+        int ret = bcf_get_format_int32(hdr,rec,"PL",arr,narr);
+        if ( ret < 0 )
+        {
+            if ( !i ) { *use_GT = 1; continue; }
+            args->nskip_no_data++;
+            return -1;
+        }
+        if ( ret != 3*bcf_hdr_nsamples(hdr) )
+        {
+            if ( warn_dip_PL )
+            {
+                fprintf(bcftools_stderr,"INFO: skipping %s:%"PRIhts_pos", only diploid FORMAT/PL fields supported. (This is printed only once.)\n", bcf_seqname(hdr,rec),rec->pos+1);
+                warn_dip_PL = 0;
+            }
+            args->nskip_dip_PL++;
+            return -1;
+        }
+        *narr1 = 3;
+        return 0;
+    }
+    return -1;  // should never reach
+}
+static void process_line(args_t *args)
+{
+    int i,j,k, nqry1, ngt1, ret;
+
+    bcf1_t *gt_rec = NULL, *qry_rec = bcf_sr_get_line(args->files,0);   // the query file
+    int qry_use_GT = args->qry_use_GT;
+    int gt_use_GT  = args->gt_use_GT;
+
+    ret = set_data(args, args->qry_hdr, qry_rec, &args->qry_arr, &args->nqry_arr, &nqry1, &qry_use_GT);
+    if ( ret<0 ) return;
+
+    if ( args->gt_hdr )
+    {
+        gt_rec = bcf_sr_get_line(args->files,1);
+        ret = set_data(args, args->gt_hdr, gt_rec, &args->gt_arr, &args->ngt_arr, &ngt1, &gt_use_GT);
+        if ( ret<0 ) return;
+    }
+    else
+    {
+        ngt1 = nqry1;
+        args->gt_arr = args->qry_arr;
+    }
+
+    // stats: number of compared sites, and used tags
+    args->ncmp++;
+    args->nused[qry_use_GT][gt_use_GT]++;
+
+    double af,hwe_dsg[8];
+    if ( args->calc_hwe_prob )
+    {
+        int ac[2];
+        if ( args->gt_hdr )
+        {
+            if ( bcf_calc_ac(args->gt_hdr, gt_rec, ac, BCF_UN_INFO|BCF_UN_FMT)!=1 ) error("todo: bcf_calc_ac() failed\n");
+        }
+        else if ( bcf_calc_ac(args->qry_hdr, qry_rec, ac, BCF_UN_INFO|BCF_UN_FMT)!=1 ) error("todo: bcf_calc_ac() failed\n");
+
+        // hwe indexes correspond to the bitmask of eight dsg combinations to account for PL uncertainty
+        // for in the extreme case we can have uninformative PL=0,0,0. So the values are the minima of e.g.
+        //      hwe[1,2,4] ..  dsg=0,1,2
+        //      hwe[3]     ..  dsg=0 or 1
+        //      hwe[6]     ..  dsg=1 or 2
+
+        double hwe[3];
+        const double min_af = 1e-5;             // cap the AF in case we get unrealistic values
+        af = (double)ac[1]/(ac[0]+ac[1]);
+        hwe[0] = af>min_af ? -log(af*af) : -log(min_af*min_af);
+        hwe[1] = af>min_af && af<1-min_af ? -log(2*af*(1-af)) : -log(2*min_af*(1-min_af));
+        hwe[2] = af<(1-min_af) ? -log((1-af)*(1-af)) : -log(min_af*min_af);
+        hwe_dsg[0] = 0;
+        for (i=1; i<8; i++)
+        {
+            hwe_dsg[i] = HUGE_VAL;
+            for (k=0; k<3; k++)
+            {
+                if ( ((1<<k)&i) && hwe_dsg[i] > hwe[k] ) hwe_dsg[i] = hwe[k];
+            }
+        }
+    }
+
+    // The sample pairs were given explicitly via -p/-P options
+    if ( args->pairs )
+    {
+        if ( !args->use_PLs )
+        {
+            int ndiff = 0;
+            if ( args->kbs_diff ) diff_sites_reset(args);
+
+            for (i=0; i<args->npairs; i++)
+            {
+                int32_t *ptr;
+                uint8_t qry_dsg, gt_dsg;
+
+                ptr = args->gt_arr + args->pairs[i].igt*ngt1;
+                gt_dsg = gt_use_GT ? gt_to_dsg(ptr) : pl_to_dsg(ptr);
+                if ( !gt_dsg ) continue;                        // missing value
+                if ( args->hom_only && !(gt_dsg&5) ) continue;  // not a hom
+
+                ptr = args->qry_arr + args->pairs[i].iqry*nqry1;
+                qry_dsg = qry_use_GT ? gt_to_dsg(ptr) : pl_to_dsg(ptr);
+                if ( !qry_dsg ) continue;                       // missing value
+
+                int match = qry_dsg & gt_dsg;
+                if ( !match )
+                {
+                    args->ndiff[i]++;
+                    if ( args->kbs_diff ) { ndiff++; kbs_insert(args->kbs_diff, i); }
+                }
+                else if ( args->calc_hwe_prob ) args->hwe_prob[i] += hwe_dsg[match];
+                args->ncnt[i]++;
+            }
+
+            if ( ndiff ) diff_sites_push(args, ndiff, qry_rec->rid, qry_rec->pos);
+        }
+        else    // use_PLs set
+        {
+            for (i=0; i<args->npairs; i++)
+            {
+                int32_t *ptr;
+                double qry_prob[3], gt_prob[3];
+                uint8_t qry_dsg, gt_dsg;
+
+                ptr = args->gt_arr + args->pairs[i].igt*ngt1;
+                gt_dsg = gt_use_GT ? gt_to_prob(args,ptr,gt_prob) : pl_to_prob(args,ptr,gt_prob);
+                if ( !gt_dsg ) continue;                        // missing value
+                if ( args->hom_only && !(gt_dsg&5) ) continue;  // not a hom
+
+                ptr = args->qry_arr + args->pairs[i].iqry*nqry1;
+                qry_dsg = qry_use_GT ? gt_to_prob(args,ptr,qry_prob) : pl_to_prob(args,ptr,qry_prob);
+                if ( !qry_dsg ) continue;                       // missing value
+
+                double min = qry_prob[0] + gt_prob[0];
+                qry_prob[1] += gt_prob[1];
+                if ( min > qry_prob[1] ) min = qry_prob[1];
+                qry_prob[2] += gt_prob[2];
+                if ( min > qry_prob[2] ) min = qry_prob[2];
+                args->pdiff[i] += min;
+
+                if ( args->calc_hwe_prob )
+                {
+                    int match = qry_dsg & gt_dsg;
+                    args->hwe_prob[i] += hwe_dsg[match];
+                }
+                args->ncnt[i]++;
+            }
+        }
+        return;
+    }
+
+    int idx=0;
+    if ( !args->use_PLs )
+    {
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int iqry = args->qry_smpl ? args->qry_smpl[i] : i;
+            int32_t *ptr = args->qry_arr + nqry1*iqry;
+            args->qry_dsg[i] = qry_use_GT ? gt_to_dsg(ptr) : pl_to_dsg(ptr);
+        }
+        if ( !args->cross_check )   // in this case gt_dsg points to qry_dsg
+        {
+            for (i=0; i<args->ngt_smpl; i++)
+            {
+                int igt = args->gt_smpl ? args->gt_smpl[i] : i;
+                int32_t *ptr = args->gt_arr + ngt1*igt;
+                args->gt_dsg[i] = gt_use_GT ? gt_to_dsg(ptr) : pl_to_dsg(ptr);
+                if ( args->hom_only && !(args->gt_dsg[i]&5) ) args->gt_dsg[i] = 0;      // not a hom, set to a missing value
+            }
+        }
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int ngt = args->cross_check ? i : args->ngt_smpl;       // two files or a sub-diagonal cross-check mode?
+            if ( !args->qry_dsg[i] ) { idx += ngt; continue; }      // missing value
+            for (j=0; j<ngt; j++)
+            {
+                if ( !args->gt_dsg[j] ) { idx++; continue; }        // missing value
+                int match = args->qry_dsg[i] & args->gt_dsg[j];
+                if ( !match ) args->ndiff[idx]++;
+                else if ( args->calc_hwe_prob ) args->hwe_prob[idx] += hwe_dsg[match];
+                args->ncnt[idx]++;
+                idx++;
+            }
+        }
+    }
+    else    // use_PLs set
+    {
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int iqry = args->qry_smpl ? args->qry_smpl[i] : i;
+            int32_t *ptr = args->qry_arr + nqry1*iqry;
+            args->qry_dsg[i] = qry_use_GT ? gt_to_prob(args,ptr,args->qry_prob+i*3) : pl_to_prob(args,ptr,args->qry_prob+i*3);
+        }
+        if ( !args->cross_check )   // in this case gt_dsg points to qry_dsg
+        {
+            for (i=0; i<args->ngt_smpl; i++)
+            {
+                int igt = args->gt_smpl ? args->gt_smpl[i] : i;
+                int32_t *ptr = args->gt_arr + ngt1*igt;
+                args->gt_dsg[i] = gt_use_GT ? gt_to_prob(args,ptr,args->gt_prob+i*3) : pl_to_prob(args,ptr,args->gt_prob+i*3);
+                if ( args->hom_only && !(args->gt_dsg[i]&5) ) args->gt_dsg[i] = 0;      // not a hom, set to a missing value
+            }
+        }
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int ngt = args->cross_check ? i : args->ngt_smpl;       // two files or a sub-diagonal cross-check mode?
+            if ( !args->qry_dsg[i] ) { idx += ngt; continue; }      // missing value
+            for (j=0; j<ngt; j++)
+            {
+                if ( !args->gt_dsg[j] ) { idx++; continue; }        // missing value
+
+                double min = args->qry_prob[i*3] + args->gt_prob[j*3];
+                if ( min > args->qry_prob[i*3+1] + args->gt_prob[j*3+1] ) min = args->qry_prob[i*3+1] + args->gt_prob[j*3+1];
+                if ( min > args->qry_prob[i*3+2] + args->gt_prob[j*3+2] ) min = args->qry_prob[i*3+2] + args->gt_prob[j*3+2];
+                args->pdiff[idx] += min;
+
+                if ( args->calc_hwe_prob )
+                {
+                    int match = args->qry_dsg[i] & args->gt_dsg[j];
+                    args->hwe_prob[idx] += hwe_dsg[match];
+                }
+                args->ncnt[idx]++;
+                idx++;
+            }
+        }
+    }
+}
+
+
+typedef struct
+{
+    int ism, idx;
+    double val;
+}
+idbl_t;
+static int cmp_idbl(const void *_a, const void *_b)
+{
+    idbl_t *a = (idbl_t*)_a;
+    idbl_t *b = (idbl_t*)_b;
+    if ( a->val < b->val ) return -1;
+    if ( a->val > b->val ) return 1;
+    return 0;
+}
+static void report_distinctive_sites(args_t *args)
+{
+    extsort_sort(args->es);
+
+    fprintf(args->fp,"# DS, distinctive sites:\n");
+    fprintf(args->fp,"#     - chromosome\n");
+    fprintf(args->fp,"#     - position\n");
+    fprintf(args->fp,"#     - cumulative number of pairs distinguished by this block\n");
+    fprintf(args->fp,"#     - block id\n");
+    fprintf(args->fp,"#DS\t[2]Chromosome\t[3]Position\t[4]Cumulative number of distinct pairs\t[5]Block id\n");
+
+    kbitset_t *kbs_blk = kbs_init(args->npairs);
+    kbitset_iter_t itr;
+    int i,ndiff,rid,pos,ndiff_tot = 0, iblock = 0;
+    int ndiff_min = args->distinctive_sites <= args->npairs ? args->distinctive_sites : args->npairs;
+    while ( diff_sites_shift(args,&ndiff,&rid,&pos) )
+    {
+        int ndiff_new = 0, ndiff_dbg = 0;
+        kbs_start(&itr);
+        while ( (i=kbs_next(args->kbs_diff, &itr))>=0 )
+        {
+            ndiff_dbg++;
+            if ( kbs_exists(kbs_blk,i) ) continue;   // already set
+            kbs_insert(kbs_blk,i);
+            ndiff_new++;
+        }
+        if ( ndiff_dbg!=ndiff ) error("Corrupted data, fixme: %d vs %d\n",ndiff_dbg,ndiff);
+        if ( !ndiff_new ) continue;     // no new pair distinguished by this site
+        ndiff_tot += ndiff_new;
+        fprintf(args->fp,"DS\t%s\t%d\t%d\t%d\n",bcf_hdr_id2name(args->qry_hdr,rid),pos+1,ndiff_tot,iblock);
+        if ( ndiff_tot < ndiff_min ) continue;   // fewer than the requested number of pairs can be distinguished at this point
+        iblock++;
+        ndiff_tot = 0;
+        kbs_clear(kbs_blk);
+    }
+    kbs_destroy(kbs_blk);
+}
+static void report(args_t *args)
+{
+    fprintf(args->fp,"INFO\tsites-compared\t%u\n",args->ncmp);
+    fprintf(args->fp,"INFO\tsites-skipped-no-match\t%u\n",args->nskip_no_match);
+    fprintf(args->fp,"INFO\tsites-skipped-multiallelic\t%u\n",args->nskip_not_ba);
+    fprintf(args->fp,"INFO\tsites-skipped-monoallelic\t%u\n",args->nskip_mono);
+    fprintf(args->fp,"INFO\tsites-skipped-no-data\t%u\n",args->nskip_no_data);
+    fprintf(args->fp,"INFO\tsites-skipped-GT-not-diploid\t%u\n",args->nskip_dip_GT);
+    fprintf(args->fp,"INFO\tsites-skipped-PL-not-diploid\t%u\n",args->nskip_dip_PL);
+    fprintf(args->fp,"INFO\tsites-used-PL-vs-PL\t%u\n",args->nused[0][0]);
+    fprintf(args->fp,"INFO\tsites-used-PL-vs-GT\t%u\n",args->nused[0][1]);
+    fprintf(args->fp,"INFO\tsites-used-GT-vs-PL\t%u\n",args->nused[1][0]);
+    fprintf(args->fp,"INFO\tsites-used-GT-vs-GT\t%u\n",args->nused[1][1]);
+    fprintf(args->fp,"# DC, discordance:\n");
+    fprintf(args->fp,"#     - query sample\n");
+    fprintf(args->fp,"#     - genotyped sample\n");
+    fprintf(args->fp,"#     - discordance (either an abstract score or number of mismatches, see -e/-u in the man page for details; smaller is better)\n");
+    fprintf(args->fp,"#     - negative log of HWE probability at matching sites (rare genotypes matches are more informative, bigger is better)\n");
+    fprintf(args->fp,"#     - number of sites compared (bigger is better)\n");
+    fprintf(args->fp,"#DC\t[2]Query Sample\t[3]Genotyped Sample\t[4]Discordance\t[5]-log P(HWE)\t[6]Number of sites compared\n");
+
+    int trim = args->ntop;
+    if ( !args->pairs )
+    {
+        if ( !args->ngt_smpl && args->nqry_smpl <= args->ntop ) trim = 0;
+        if ( args->ngt_smpl && args->ngt_smpl <= args->ntop  ) trim = 0;
+    }
+
+    if ( args->pairs )
+    {
+        int i;
+        for (i=0; i<args->npairs; i++)
+        {
+            int iqry = args->pairs[i].iqry;
+            int igt  = args->pairs[i].igt;
+            if ( args->ndiff )
+            {
+                fprintf(args->fp,"DC\t%s\t%s\t%u\t%e\t%u\n",
+                        args->qry_hdr->samples[iqry],
+                        args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                        args->ndiff[i],
+                        args->calc_hwe_prob ? args->hwe_prob[i] : 0,
+                        args->ncnt[i]);
+            }
+            else
+            {
+                fprintf(args->fp,"DC\t%s\t%s\t%e\t%e\t%u\n",
+                        args->qry_hdr->samples[iqry],
+                        args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                        args->pdiff[i],
+                        args->calc_hwe_prob ? args->hwe_prob[i] : 0,
+                        args->ncnt[i]);
+            }
+        }
+    }
+    else if ( !trim )
+    {
+        int i,j,idx=0;
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int iqry = args->qry_smpl ? args->qry_smpl[i] : i;
+            int ngt  = args->cross_check ? i : args->ngt_smpl;
+            for (j=0; j<ngt; j++)
+            {
+                int igt = args->gt_smpl ? args->gt_smpl[j] : j;
+                if ( args->ndiff )
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%u\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                            args->ndiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+                else
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%e\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                            args->pdiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+                idx++;
+            }
+        }
+    }
+    else if ( !args->cross_check )
+    {
+        idbl_t *arr = (idbl_t*)malloc(sizeof(*arr)*args->ngt_smpl);
+        int i,j;
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            int idx  = i*args->ngt_smpl;
+            for (j=0; j<args->ngt_smpl; j++)
+            {
+                if ( args->sort_by_hwe )
+                    arr[j].val = -args->hwe_prob[idx];
+                else if ( args->ndiff )
+                    arr[j].val = args->ncnt[idx] ? (double)args->ndiff[idx]/args->ncnt[idx] : 0;
+                else
+                    arr[j].val = args->ncnt[idx] ? args->pdiff[idx]/args->ncnt[idx] : 0;
+                arr[j].ism = j;
+                arr[j].idx = idx;
+                idx++;
+            }
+            qsort(arr, args->ngt_smpl, sizeof(*arr), cmp_idbl);
+            int iqry = args->qry_smpl ? args->qry_smpl[i] : i;
+            for (j=0; j<args->ntop; j++)
+            {
+                int idx = arr[j].idx;
+                int igt = args->gt_smpl ? args->gt_smpl[arr[j].ism] : arr[j].ism;
+                if ( args->ndiff )
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%u\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                            args->ndiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+                else
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%e\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->gt_hdr?args->gt_hdr->samples[igt]:args->qry_hdr->samples[igt],
+                            args->pdiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+            }
+        }
+        free(arr);
+    }
+    else
+    {
+        int narr = args->nqry_smpl-1;
+        idbl_t *arr = (idbl_t*)malloc(sizeof(*arr)*narr);
+        int i,j,k,idx;
+        for (i=0; i<args->nqry_smpl; i++)
+        {
+            k = 0, idx = i*(i-1)/2;
+            for (j=0; j<i; j++)
+            {
+                if ( args->sort_by_hwe )
+                    arr[k].val = -args->hwe_prob[idx];
+                else if ( args->ndiff )
+                    arr[k].val = args->ncnt[idx] ? (double)args->ndiff[idx]/args->ncnt[idx] : 0;
+                else
+                    arr[k].val = args->ncnt[idx] ? args->pdiff[idx]/args->ncnt[idx] : 0;
+                arr[k].ism = j;
+                arr[k].idx = idx;
+                idx++;
+                k++;
+            }
+            for (; j<narr; j++)
+            {
+                idx = j*(j+1)/2 + i;
+                if ( args->sort_by_hwe )
+                    arr[k].val = -args->hwe_prob[idx];
+                else if ( args->ndiff )
+                    arr[k].val = args->ncnt[idx] ? (double)args->ndiff[idx]/args->ncnt[idx] : 0;
+                else
+                    arr[k].val = args->ncnt[idx] ? args->pdiff[idx]/args->ncnt[idx] : 0;
+                arr[k].ism = j + 1;
+                arr[k].idx = idx;
+                k++;
+            }
+            qsort(arr, narr, sizeof(*arr), cmp_idbl);
+            int iqry = args->qry_smpl ? args->qry_smpl[i] : i;
+            for (j=0; j<args->ntop; j++)
+            {
+                if ( i <= arr[j].ism ) continue;
+                int idx = arr[j].idx;
+                int igt = args->qry_smpl ? args->qry_smpl[arr[j].ism] : arr[j].ism;
+                if ( args->ndiff )
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%u\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->qry_hdr->samples[igt],
+                            args->ndiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+                else
+                {
+                    fprintf(args->fp,"DC\t%s\t%s\t%e\t%e\t%u\n",
+                            args->qry_hdr->samples[iqry],
+                            args->qry_hdr->samples[igt],
+                            args->pdiff[idx],
+                            args->calc_hwe_prob ? args->hwe_prob[idx] : 0,
+                            args->ncnt[idx]);
+                }
+            }
+        }
+        free(arr);
+    }
+}
+
+static int is_input_okay(args_t *args, int nmatch)
+{
+    int i;
+    const char *msg;
+    bcf_hdr_t *hdr;
+    bcf1_t *rec;
+    if ( args->gt_hdr && nmatch!=2 )
+    {
+        if ( args->nskip_no_match++ ) return 0;
+        for (i=0; i<2; i++)
+        {
+            rec = bcf_sr_get_line(args->files,i);
+            if ( rec ) break;
+        }
+        hdr = bcf_sr_get_header(args->files,i);
+        fprintf(bcftools_stderr,"INFO: skipping %s:%"PRIhts_pos", no record with matching POS+ALT. (This is printed only once.)\n",
+                bcf_seqname(hdr,rec),rec->pos+1);
+        return 0;
+    }
+    for (i=0; i<2; i++)
+    {
+        hdr = bcf_sr_get_header(args->files,i);
+        rec = bcf_sr_get_line(args->files,i);
+        if ( rec->n_allele>2 )
+        {
+            if ( args->nskip_not_ba++ ) return 0;
+            msg = "not a biallelic site, run `bcftools norm -m -` first";
+            goto not_okay;
+        }
+        if ( bcf_get_variant_types(rec)==VCF_REF )
+        {
+            if ( args->nskip_mono++ ) return 0;
+            msg = "monoallelic site";
+            goto not_okay;
+        }
+        if ( !args->gt_hdr ) break;
+    }
+    return 1;
+
+not_okay:
+    fprintf(bcftools_stderr,"INFO: skipping %s:%"PRIhts_pos", %s. (This is printed only once.)\n",
+        bcf_seqname(hdr,rec),rec->pos+1,msg);
+    return 0;
+}
+
+static void usage(void)
+{
+    fprintf(bcftools_stderr, "\n");
+    fprintf(bcftools_stderr, "About:   Check sample identity. With no -g BCF given, multi-sample cross-check is performed.\n");
+    fprintf(bcftools_stderr, "Usage:   bcftools gtcheck [options] [-g <genotypes.vcf.gz>] <query.vcf.gz>\n");
+    fprintf(bcftools_stderr, "\n");
+    fprintf(bcftools_stderr, "Options:\n");
+    //fprintf(bcftools_stderr, "    -a, --all-sites                  Output comparison for all sites\n");
+    //fprintf(bcftools_stderr, "    -c, --cluster MIN,MAX            Min inter- and max intra-sample error [0.23,-0.3]\n");
+    fprintf(bcftools_stderr, "        --distinctive-sites            Find sites that can distinguish between at least NUM sample pairs.\n");
+    fprintf(bcftools_stderr, "                  NUM[,MEM[,TMP]]          If the number is smaller or equal to 1, it is interpreted as the fraction of pairs.\n");
+    fprintf(bcftools_stderr, "                                           The optional MEM string sets the maximum memory used for in-memory sorting [500M]\n");
+#ifdef _WIN32
+    fprintf(bcftools_stderr, "                                           and TMP is a prefix of temporary files used by external sorting [/bcftools.XXXXXX]\n");
+#else
+    fprintf(bcftools_stderr, "                                           and TMP is a prefix of temporary files used by external sorting [/tmp/bcftools.XXXXXX]\n");
+#endif
+    fprintf(bcftools_stderr, "        --dry-run                      Stop after first record to estimate required time\n");
+    fprintf(bcftools_stderr, "    -e, --error-probability INT        Phred-scaled probability of genotyping error, 0 for faster but less accurate results [40]\n");
+    fprintf(bcftools_stderr, "    -g, --genotypes FILE               Genotypes to compare against\n");
+    fprintf(bcftools_stderr, "    -H, --homs-only                    Homozygous genotypes only, useful with low coverage data (requires -g)\n");
+    fprintf(bcftools_stderr, "        --n-matches INT                Print only top INT matches for each sample (sorted by average score), 0 for unlimited.\n");
+    fprintf(bcftools_stderr, "                                           Use negative value to sort by HWE probability rather than by discordance [0]\n");
+    fprintf(bcftools_stderr, "        --no-HWE-prob                  Disable calculation of HWE probability\n");
+    fprintf(bcftools_stderr, "    -p, --pairs LIST                   Comma-separated sample pairs to compare (qry,gt[,qry,gt..] with -g or qry,qry[,qry,qry..] w/o)\n");
+    fprintf(bcftools_stderr, "    -P, --pairs-file FILE              File with tab-delimited sample pairs to compare (qry,gt with -g or qry,qry w/o)\n");
+    fprintf(bcftools_stderr, "    -r, --regions REGION               Restrict to comma-separated list of regions\n");
+    fprintf(bcftools_stderr, "    -R, --regions-file FILE            Restrict to regions listed in a file\n");
+    fprintf(bcftools_stderr, "        --regions-overlap 0|1|2        Include if POS in the region (0), record overlaps (1), variant overlaps (2) [1]\n");
+    fprintf(bcftools_stderr, "    -s, --samples [qry|gt]:LIST        List of query or -g samples, \"-\" to select all samples (by default all samples are compared)\n");
+    fprintf(bcftools_stderr, "    -S, --samples-file [qry|gt]:FILE   File with the query or -g samples to compare\n");
+    fprintf(bcftools_stderr, "    -t, --targets REGION               Similar to -r but streams rather than index-jumps\n");
+    fprintf(bcftools_stderr, "    -T, --targets-file FILE            Similar to -R but streams rather than index-jumps\n");
+    fprintf(bcftools_stderr, "        --targets-overlap 0|1|2        Include if POS in the region (0), record overlaps (1), variant overlaps (2) [0]\n");
+    fprintf(bcftools_stderr, "    -u, --use TAG1[,TAG2]              Which tag to use in the query file (TAG1) and the -g file (TAG2) [PL,GT]\n");
+    fprintf(bcftools_stderr, "Examples:\n");
+    fprintf(bcftools_stderr, "   # Check discordance of all samples from B against all sample in A\n");
+    fprintf(bcftools_stderr, "   bcftools gtcheck -g A.bcf B.bcf\n");
+    fprintf(bcftools_stderr, "\n");
+    fprintf(bcftools_stderr, "   # Limit comparisons to the fiven list of samples\n");
+    fprintf(bcftools_stderr, "   bcftools gtcheck -s gt:a1,a2,a3 -s qry:b1,b2 -g A.bcf B.bcf\n");
+    fprintf(bcftools_stderr, "\n");
+    fprintf(bcftools_stderr, "   # Compare only two pairs a1,b1 and a1,b2\n");
+    fprintf(bcftools_stderr, "   bcftools gtcheck -p a1,b1,a1,b2 -g A.bcf B.bcf\n");
+    fprintf(bcftools_stderr, "\n");
+    bcftools_exit(1);
+}
+
+int main_vcfgtcheck(int argc, char *argv[])
+{
+    int c;
+    args_t *args = (args_t*) calloc(1,sizeof(args_t));
+    args->argc   = argc; args->argv = argv; set_cwd(args);
+    args->qry_use_GT = -1;
+    args->gt_use_GT  = -1;
+    args->calc_hwe_prob = 1;
+    args->use_PLs = 40;
+    args->regions_overlap = 1;
+    args->targets_overlap = 0;
+
+    // external sort for --distinctive-sites
+#ifdef _WIN32
+    args->es_tmp_prefix = NULL;
+#else
+    args->es_tmp_prefix = "/tmp/bcftools-gtcheck";
+#endif
+    args->es_max_mem = strdup("500M");
+
+    // In simulated sample swaps the minimum error was 0.3 and maximum intra-sample error was 0.23
+    //    - min_inter: pairs with smaller err value will be considered identical
+    //    - max_intra: pairs with err value bigger than abs(max_intra_err) will be considered
+    //                  different. If negative, the cutoff may be heuristically lowered
+    args->min_inter_err =  0.23;
+    args->max_intra_err = -0.3;
+
+    static struct option loptions[] =
+    {
+        {"error-probability",1,0,'e'},
+        {"use",1,0,'u'},
+        {"cluster",1,0,'c'},
+        {"GTs-only",1,0,'G'},
+        {"all-sites",0,0,'a'},
+        {"homs-only",0,0,'H'},
+        {"help",0,0,'h'},
+        {"genotypes",1,0,'g'},
+        {"plot",1,0,'p'},
+        {"samples",1,0,'s'},
+        {"samples-file",1,0,'S'},
+        {"n-matches",1,0,2},
+        {"no-HWE-prob",0,0,3},
+        {"target-sample",1,0,4},
+        {"dry-run",0,0,5},
+        {"distinctive-sites",1,0,6},
+        {"regions",1,0,'r'},
+        {"regions-file",1,0,'R'},
+        {"regions-overlap",required_argument,NULL,7},
+        {"targets",1,0,'t'},
+        {"targets-file",1,0,'T'},
+        {"targets-overlap",required_argument,NULL,8},
+        {"pairs",1,0,'p'},
+        {"pairs-file",1,0,'P'},
+        {0,0,0,0}
+    };
+    char *tmp;
+    while ((c = getopt_long(argc, argv, "hg:p:s:S:p:P:Hr:R:at:T:G:c:u:e:",loptions,NULL)) >= 0) {
+        switch (c) {
+            case 'e':
+                args->use_PLs = strtol(optarg,&tmp,10);
+                if ( !tmp || *tmp ) error("Could not parse: --error-probability %s\n", optarg);
+                break;
+            case 'u':
+                {
+                    int i,nlist;
+                    char **list = hts_readlist(optarg, 0, &nlist);
+                    if ( !list || nlist<=0 || nlist>2 ) error("Failed to parse --use %s\n", optarg);
+                    if ( !strcasecmp("GT",list[0]) ) args->qry_use_GT = 1;
+                    else if ( !strcasecmp("PL",list[0]) ) args->qry_use_GT = 0;
+                    else error("Failed to parse --use %s; only GT and PL are supported\n", optarg);
+                    if ( nlist==2 )
+                    {
+                        if ( !strcasecmp("GT",list[1]) ) args->gt_use_GT = 1;
+                        else if ( !strcasecmp("PL",list[1]) ) args->gt_use_GT = 0;
+                        else error("Failed to parse --use %s; only GT and PL are supported\n", optarg);
+                    }
+                    else args->gt_use_GT = args->qry_use_GT;
+                    for (i=0; i<nlist; i++) free(list[i]);
+                    free(list);
+                }
+                break;
+            case 2 :
+                args->ntop = strtol(optarg,&tmp,10);
+                if ( !tmp || *tmp ) error("Could not parse: --n-matches %s\n", optarg);
+                if ( args->ntop < 0 )
+                {
+                    args->sort_by_hwe = 1;
+                    args->ntop *= -1;
+                }
+                break;
+            case 3 : args->calc_hwe_prob = 0; break;
+            case 4 : error("The option -S, --target-sample has been deprecated\n"); break;
+            case 5 : args->dry_run = 1; break;
+            case 6 :
+                args->distinctive_sites = strtod(optarg,&tmp);
+                if ( *tmp )
+                {
+                    if ( *tmp!=',' ) error("Could not parse: --distinctive-sites %s\n", optarg);
+                    tmp++;
+                    free(args->es_max_mem);
+                    args->es_max_mem = strdup(tmp);
+                    while ( *tmp && *tmp!=',' ) tmp++;
+                    if ( *tmp ) { *tmp = 0; args->es_tmp_prefix = tmp+1; }
+                }
+                args->use_PLs = 0;
+                break;
+            case 'c':
+                error("The -c option is to be implemented, please open an issue on github\n");
+                args->min_inter_err = strtod(optarg,&tmp);
+                if ( *tmp )
+                {
+                    if ( *tmp!=',') error("Could not parse: -c %s\n", optarg);
+                    args->max_intra_err = strtod(tmp+1,&tmp);
+                    if ( *tmp ) error("Could not parse: -c %s\n", optarg);
+                }
+                break;
+            case 'G': error("The option -G, --GTs-only has been deprecated\n"); break;
+            case 'a': args->all_sites = 1; error("The -a option is to be implemented, please open an issue on github\n"); break;
+            case 'H': args->hom_only = 1; break;
+            case 'g': args->gt_fname = optarg; break;
+//            case 'p': args->plot = optarg; break;
+            case 's':
+                if ( !strncasecmp("gt:",optarg,3) ) args->gt_samples = optarg+3;
+                else if ( !strncasecmp("qry:",optarg,4) ) args->qry_samples = optarg+4;
+                else error("Which one? Query samples (qry:%s) or genotype samples (gt:%s)?\n",optarg,optarg);
+                break;
+            case 'S':
+                if ( !strncasecmp("gt:",optarg,3) ) args->gt_samples = optarg+3, args->gt_samples_is_file = 1;
+                else if ( !strncasecmp("qry:",optarg,4) ) args->qry_samples = optarg+4, args->qry_samples_is_file = 1;
+                else error("Which one? Query samples (qry:%s) or genotype samples (gt:%s)?\n",optarg,optarg);
+                break;
+            case 'p': args->pair_samples = optarg; break;
+            case 'P': args->pair_samples = optarg; args->pair_samples_is_file = 1; break;
+            case 'r': args->regions = optarg; break;
+            case 'R': args->regions = optarg; args->regions_is_file = 1; break;
+            case 't': args->targets = optarg; break;
+            case 'T': args->targets = optarg; args->targets_is_file = 1; break;
+            case  7 :
+                args->regions_overlap = parse_overlap_option(optarg);
+                if ( args->regions_overlap < 0 ) error("Could not parse: --regions-overlap %s\n",optarg);
+                break;
+            case  8 :
+                args->targets_overlap = parse_overlap_option(optarg);
+                if ( args->targets_overlap < 0 ) error("Could not parse: --targets-overlap %s\n",optarg);
+                break;
+            case 'h':
+            case '?': usage(); break;
+            default: error("Unknown argument: %s\n", optarg);
+        }
+    }
+    if ( optind==argc )
+    {
+        if ( !isatty(fileno((FILE *)stdin)) ) args->qry_fname = "-";  // reading from stdin
+        else usage();   // no files given
+    }
+    else args->qry_fname = argv[optind];
+    if ( argc>optind+1 ) error("Error: too many files given, run with -h for help\n");  // too many files given
+    if ( args->pair_samples )
+    {
+        if ( args->gt_samples || args->qry_samples ) error("The -p/-P option cannot be combined with -s/-S\n");
+        if ( args->ntop ) error("The --n-matches option cannot be combined with -p/-P\n");
+    }
+    if ( args->distinctive_sites && !args->pair_samples ) error("The experimental option --distinctive-sites requires -p/-P\n");
+    if ( args->hom_only && !args->gt_fname ) error("The option --homs-only requires --genotypes\n");
+    if ( args->distinctive_sites && args->use_PLs ) error("The option --distinctive-sites cannot be combined with --error-probability\n");
+
+    init_data(args);
+
+    int ret;
+    while ( (ret=bcf_sr_next_line(args->files)) )
+    {
+        if ( !is_input_okay(args,ret) ) continue;
+
+        // time one record to give the user an estimate with very big files
+        struct timeval t0, t1;
+        if ( !args->ncmp )  gettimeofday(&t0, NULL);
+
+        process_line(args);
+
+        if ( args->ncmp==1 )
+        {
+            gettimeofday(&t1, NULL);
+            double delta = (t1.tv_sec - t0.tv_sec) * 1e6 + (t1.tv_usec - t0.tv_usec);
+            fprintf(bcftools_stderr,"INFO:\tTime required to process one record .. %f seconds\n",delta/1e6);
+            fprintf(args->fp,"INFO\tTime required to process one record .. %f seconds\n",delta/1e6);
+            if ( args->dry_run ) break;
+        }
+    }
+    if ( !args->dry_run )
+    {
+        report(args);
+        if ( args->distinctive_sites ) report_distinctive_sites(args);
+    }
+
+    destroy_data(args);
+    free(args);
+    return 0;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/bcftools/vcfsort.c

@@ -0,0 +1,460 @@
+/*  vcfsort.c -- sort subcommand
+
+   Copyright (C) 2017-2023 Genome Research Ltd.
+
+   Author: Petr Danecek <pd3@sanger.ac.uk>
+
+   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.
+
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <math.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#include <htslib/vcf.h>
+#include <htslib/kstring.h>
+#include <htslib/hts_os.h>
+#include "kheap.h"
+#include "bcftools.h"
+
+typedef struct
+{
+    char *fname;
+    htsFile *fh;
+    bcf1_t *rec;
+}
+blk_t;
+
+typedef struct _args_t
+{
+    bcf_hdr_t *hdr;
+    char **argv, *fname, *output_fname, *tmp_dir;
+    int argc, output_type, clevel;
+    size_t max_mem, mem;
+    bcf1_t **buf;
+    uint8_t *mem_block;
+    size_t nbuf, mbuf, nblk;
+    blk_t *blk;
+    char *index_fn;
+    int write_index;
+}
+args_t;
+
+void clean_files(args_t *args)
+{
+    int i;
+    fprintf(stderr,"Cleaning\n");
+    for (i=0; i<args->nblk; i++)
+    {
+        blk_t *blk = args->blk + i;
+        if ( blk->fname )
+        {
+            unlink(blk->fname);
+            free(blk->fname);
+        }
+        if ( blk->rec )
+            bcf_destroy(blk->rec);
+    }
+    rmdir(args->tmp_dir);
+}
+void clean_files_and_throw(args_t *args, const char *format, ...)
+{
+    va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    va_end(ap);
+    clean_files(args);
+    exit(-1);
+}
+
+int cmp_bcf_pos(const void *aptr, const void *bptr)
+{
+    bcf1_t *a = *((bcf1_t**)aptr);
+    bcf1_t *b = *((bcf1_t**)bptr);
+    if ( a->rid < b->rid ) return -1;
+    if ( a->rid > b->rid ) return 1;
+    if ( a->pos < b->pos ) return -1;
+    if ( a->pos > b->pos ) return 1;
+
+    // Sort the same chr:pos records lexicographically by ref,alt.
+    // This will be called rarely so should not slow the sorting down
+    // noticeably.
+
+    int i;
+    for (i=0; i<a->n_allele; i++)
+    {
+        if ( i >= b->n_allele ) return 1;
+        int ret = strcasecmp(a->d.allele[i],b->d.allele[i]);
+        if ( ret ) return ret;
+    }
+    if ( a->n_allele < b->n_allele ) return -1;
+    return 0;
+}
+
+void buf_flush(args_t *args)
+{
+    if ( !args->nbuf ) return;
+
+    qsort(args->buf, args->nbuf, sizeof(*args->buf), cmp_bcf_pos);
+
+    args->nblk++;
+    args->blk = (blk_t*) realloc(args->blk, sizeof(blk_t)*args->nblk);
+    if ( !args->blk ) error("Error: could not allocate %zu bytes of memory, try reducing --max-mem\n",sizeof(blk_t)*args->nblk);
+    blk_t *blk = args->blk + args->nblk - 1;
+
+    kstring_t str = {0,0,0};
+    ksprintf(&str, "%s/%05d.bcf", args->tmp_dir, (int)args->nblk);
+    blk->fname = str.s;
+    blk->rec   = NULL;
+    blk->fh    = NULL;
+
+    htsFile *fh = hts_open(blk->fname, "wbu");
+    if ( fh == NULL ) clean_files_and_throw(args, "Cannot write %s: %s\n", blk->fname, strerror(errno));
+    if ( bcf_hdr_write(fh, args->hdr)!=0 ) clean_files_and_throw(args, "[%s] Error: cannot write to %s\n", __func__,blk->fname);
+
+    int i;
+    for (i=0; i<args->nbuf; i++)
+    {
+        if ( bcf_write(fh, args->hdr, args->buf[i])!=0 ) clean_files_and_throw(args, "[%s] Error: cannot write to %s\n", __func__,blk->fname);
+    }
+    if ( hts_close(fh)!=0 ) clean_files_and_throw(args, "[%s] Error: close failed .. %s\n", __func__,blk->fname);
+
+    args->nbuf = 0;
+    args->mem  = 0;
+}
+
+
+static inline uint8_t *_align_up(uint8_t *ptr)
+{
+    return (uint8_t*)(((size_t)ptr + 8 - 1) & ~((size_t)(8 - 1)));
+}
+
+void buf_push(args_t *args, bcf1_t *rec)
+{
+    size_t delta = sizeof(bcf1_t) + rec->shared.l + rec->indiv.l + rec->unpack_size[0] + rec->unpack_size[1]
+        + sizeof(*rec->d.allele)*rec->d.m_allele
+        + sizeof(bcf1_t*)       // args->buf
+        + 8;                    // the number of _align_up() calls
+
+    if ( delta > args->max_mem - args->mem )
+    {
+        args->nbuf++;
+        hts_expand(bcf1_t*, args->nbuf, args->mbuf, args->buf);
+        args->buf[args->nbuf-1] = rec;
+        buf_flush(args);
+        bcf_destroy(rec);
+        return;
+    }
+
+    // make sure nothing has changed in htslib
+    assert( rec->unpacked==BCF_UN_STR && !rec->d.flt && !rec->d.info && !rec->d.fmt && !rec->d.var );
+
+    uint8_t *ptr_beg = args->mem_block + args->mem;
+    uint8_t *ptr = _align_up(ptr_beg);
+    bcf1_t *new_rec = (bcf1_t*)ptr;
+    memcpy(new_rec,rec,sizeof(*rec));
+    ptr += sizeof(*rec);
+
+    // The array of allele pointers does not need alignment as bcf1_t is already padded to the biggest
+    // data type in the structure
+    char **allele = (char**)ptr;
+    ptr += rec->n_allele*sizeof(*allele);
+
+    // This is just to prevent valgrind from complaining about memcpy, unpack_size is a high-water mark
+    // and the end may be uninitialized
+    delta = rec->d.allele[rec->n_allele-1] - rec->d.allele[0];
+    while ( delta < rec->unpack_size[1] ) if ( !rec->d.als[delta++] ) break;
+    memcpy(ptr,rec->d.als,delta);
+    new_rec->d.als = (char*)ptr;
+    ptr = ptr + delta;
+
+    int i;
+    for (i=0; i<rec->n_allele; i++) allele[i] = new_rec->d.als + (ptrdiff_t)(rec->d.allele[i] - rec->d.allele[0]);
+    new_rec->d.allele = allele;
+
+    memcpy(ptr,rec->shared.s,rec->shared.l);
+    new_rec->shared.s = (char*)ptr;
+    new_rec->shared.m = rec->shared.l;
+    ptr += rec->shared.l;
+
+    memcpy(ptr,rec->indiv.s,rec->indiv.l);
+    new_rec->indiv.s = (char*)ptr;
+    new_rec->indiv.m = rec->indiv.l;
+    ptr += rec->indiv.l;
+
+    // This is just to prevent valgrind from complaining about memcpy, unpack_size is a high-water mark
+    // and the end may be uninitialized
+    i = 0;
+    while ( i < rec->unpack_size[0] ) if ( !rec->d.id[i++] ) break;
+    memcpy(ptr,rec->d.id,i);
+    new_rec->d.id = (char*)ptr;
+    ptr += i;
+
+    args->nbuf++;
+    hts_expand(bcf1_t*, args->nbuf, args->mbuf, args->buf);
+    args->buf[args->nbuf-1] = new_rec;
+
+    delta = ptr - ptr_beg;
+    args->mem += delta;
+
+    assert( args->mem <= args->max_mem );
+
+    bcf_destroy(rec);
+}
+
+void sort_blocks(args_t *args)
+{
+    htsFile *in = hts_open(args->fname, "r");
+    if ( !in ) clean_files_and_throw(args, "Could not read %s\n", args->fname);
+    args->hdr = bcf_hdr_read(in);
+    if ( !args->hdr) clean_files_and_throw(args, "Could not read VCF/BCF headers from %s\n", args->fname);
+
+    while ( 1 )
+    {
+        bcf1_t *rec = bcf_init();
+        int ret = bcf_read1(in, args->hdr, rec);
+        if ( ret < -1 ) clean_files_and_throw(args,"Error encountered while parsing the input\n");
+        if ( ret == -1 )
+        {
+            bcf_destroy(rec);
+            break;
+        }
+        if ( rec->errcode ) clean_files_and_throw(args,"Error encountered while parsing the input at %s:%d\n",bcf_seqname(args->hdr,rec),rec->pos+1);
+        bcf_unpack(rec, BCF_UN_STR);
+        buf_push(args, rec);
+    }
+    buf_flush(args);
+    free(args->buf);
+
+    if ( hts_close(in)!=0 ) clean_files_and_throw(args,"Close failed: %s\n", args->fname);
+}
+
+static inline int blk_is_smaller(blk_t **aptr, blk_t **bptr)
+{
+    blk_t *a = *aptr;
+    blk_t *b = *bptr;
+    int ret = cmp_bcf_pos(&a->rec, &b->rec);
+    if ( ret < 0 ) return 1;
+    return 0;
+}
+KHEAP_INIT(blk, blk_t*, blk_is_smaller)
+
+void blk_read(args_t *args, khp_blk_t *bhp, bcf_hdr_t *hdr, blk_t *blk)
+{
+    if ( !blk->fh ) return;
+    int ret = bcf_read(blk->fh, hdr, blk->rec);
+    if ( ret < -1 ) clean_files_and_throw(args, "Error reading %s\n", blk->fname);
+    if ( ret == -1 )
+    {
+        if ( hts_close(blk->fh)!=0 ) clean_files_and_throw(args, "Close failed: %s\n", blk->fname);
+        blk->fh = 0;
+        return;
+    }
+    bcf_unpack(blk->rec, BCF_UN_STR);
+    khp_insert(blk, bhp, &blk);
+}
+
+void merge_blocks(args_t *args)
+{
+    fprintf(stderr,"Merging %d temporary files\n", (int)args->nblk);
+    khp_blk_t *bhp = khp_init(blk);
+
+    int i;
+    for (i=0; i<args->nblk; i++)
+    {
+        blk_t *blk = args->blk + i;
+        blk->fh = hts_open(blk->fname, "r");
+        if ( !blk->fh ) clean_files_and_throw(args, "Could not read %s: %s\n", blk->fname, strerror(errno));
+        bcf_hdr_t *hdr = bcf_hdr_read(blk->fh);
+        bcf_hdr_destroy(hdr);
+        blk->rec = bcf_init();
+        blk_read(args, bhp, args->hdr, blk);
+    }
+
+    char wmode[8];
+    set_wmode(wmode,args->output_type,args->output_fname,args->clevel);
+    htsFile *out = hts_open(args->output_fname ? args->output_fname : "-", wmode);
+    if ( bcf_hdr_write(out, args->hdr)!=0 ) clean_files_and_throw(args, "[%s] Error: cannot write to %s\n", __func__,args->output_fname);
+    if ( args->write_index && init_index(out,args->hdr,args->output_fname,&args->index_fn)<0 ) error("Error: failed to initialise index for %s\n",args->output_fname);
+    while ( bhp->ndat )
+    {
+        blk_t *blk = bhp->dat[0];
+        if ( bcf_write(out, args->hdr, blk->rec)!=0 ) clean_files_and_throw(args, "[%s] Error: cannot write to %s\n", __func__,args->output_fname);
+        khp_delete(blk, bhp);
+        blk_read(args, bhp, args->hdr, blk);
+    }
+    if ( args->write_index )
+    {
+        if ( bcf_idx_save(out)<0 )
+        {
+            if ( hts_close(out)!=0 ) error("Error: close failed .. %s\n", args->output_fname?args->output_fname:"stdout");
+            error("Error: cannot write to index %s\n", args->index_fn);
+        }
+        free(args->index_fn);
+    }
+    if ( hts_close(out)!=0 ) clean_files_and_throw(args, "Close failed: %s\n", args->output_fname);
+
+    clean_files(args);
+
+    free(args->blk);
+    khp_destroy(blk, bhp);
+    fprintf(stderr,"Done\n");
+}
+
+static void usage(args_t *args)
+{
+    fprintf(stderr, "\n");
+    fprintf(stderr, "About:   Sort VCF/BCF file.\n");
+    fprintf(stderr, "Usage:   bcftools sort [OPTIONS] <FILE.vcf>\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "Options:\n");
+    fprintf(stderr, "    -m, --max-mem FLOAT[kMG]       maximum memory to use [768M]\n");    // using metric units, 1M=1e6
+    fprintf(stderr, "    -o, --output FILE              output file name [stdout]\n");
+    fprintf(stderr, "    -O, --output-type b|u|z|v      b: compressed BCF, u: uncompressed BCF, z: compressed VCF, v: uncompressed VCF [v]\n");
+    fprintf(stderr, "    -O, --output-type u|b|v|z[0-9] u/b: un/compressed BCF, v/z: un/compressed VCF, 0-9: compression level [v]\n");
+
+#ifdef _WIN32
+    fprintf(stderr, "    -T, --temp-dir DIR             temporary files [/bcftools.XXXXXX]\n");
+#else
+    fprintf(stderr, "    -T, --temp-dir DIR             temporary files [/tmp/bcftools.XXXXXX]\n");
+#endif
+    fprintf(stderr, "        --write-index              Automatically index the output files [off]\n");
+    fprintf(stderr, "\n");
+    exit(1);
+}
+
+size_t parse_mem_string(const char *str)
+{
+    char *tmp;
+    double mem = strtod(str, &tmp);
+    if ( tmp==str ) error("Could not parse the memory string: \"%s\"\n", str);
+    if ( !strcasecmp("k",tmp) ) mem *= 1000;
+    else if ( !strcasecmp("m",tmp) ) mem *= 1000*1000;
+    else if ( !strcasecmp("g",tmp) ) mem *= 1000*1000*1000;
+    return mem;
+}
+
+void mkdir_p(const char *fmt, ...);
+static void init(args_t *args)
+{
+    args->max_mem *= 0.9;
+    args->mem_block = malloc(args->max_mem);
+    if ( !args->mem_block ) error("Error: could not allocate %zu bytes of memory, try reducing --max-mem\n",args->max_mem);
+    args->mem = 0;
+
+    args->tmp_dir = init_tmp_prefix(args->tmp_dir);
+
+#ifdef _WIN32
+        int ret = mkdir(mktemp(args->tmp_dir), 0700);
+        if ( ret ) error("mkdir(%s) failed: %s\n", args->tmp_dir,strerror(errno));
+#else
+        char *tmp = mkdtemp(args->tmp_dir);
+        if ( !tmp ) error("mkdtemp(%s) failed: %s\n",  args->tmp_dir,strerror(errno));
+        int ret = chmod(tmp, S_IRUSR|S_IWUSR|S_IXUSR);
+        if ( ret ) error("chmod(%s,S_IRUSR|S_IWUSR|S_IXUSR) failed: %s\n", args->tmp_dir,strerror(errno));
+#endif
+
+    fprintf(stderr,"Writing to %s\n", args->tmp_dir);
+}
+static void destroy(args_t *args)
+{
+    bcf_hdr_destroy(args->hdr);
+    free(args->mem_block);
+    free(args->tmp_dir);
+    free(args);
+}
+
+int main_sort(int argc, char *argv[])
+{
+    int c;
+    args_t *args  = (args_t*) calloc(1,sizeof(args_t));
+    args->argc    = argc; args->argv = argv;
+    args->max_mem = 768*1000*1000;
+    args->output_fname = "-";
+    args->clevel = -1;
+
+    static struct option loptions[] =
+    {
+        {"max-mem",required_argument,NULL,'m'},
+        {"temp-dir",required_argument,NULL,'T'},
+        {"output-type",required_argument,NULL,'O'},
+        {"output-file",required_argument,NULL,'o'},
+        {"output",required_argument,NULL,'o'},
+        {"help",no_argument,NULL,'h'},
+        {"write-index",no_argument,NULL,1},
+        {0,0,0,0}
+    };
+    char *tmp;
+    while ((c = getopt_long(argc, argv, "m:T:O:o:h?",loptions,NULL)) >= 0)
+    {
+        switch (c)
+        {
+            case 'm': args->max_mem = parse_mem_string(optarg); break;
+            case 'T': args->tmp_dir = optarg; break;
+            case 'o': args->output_fname = optarg; break;
+            case 'O':
+                      switch (optarg[0]) {
+                          case 'b': args->output_type = FT_BCF_GZ; break;
+                          case 'u': args->output_type = FT_BCF; break;
+                          case 'z': args->output_type = FT_VCF_GZ; break;
+                          case 'v': args->output_type = FT_VCF; break;
+                          default:
+                          {
+                              args->clevel = strtol(optarg,&tmp,10);
+                              if ( *tmp || args->clevel<0 || args->clevel>9 ) error("The output type \"%s\" not recognised\n", optarg);
+                          }
+                      };
+                      if ( optarg[1] )
+                      {
+                          args->clevel = strtol(optarg+1,&tmp,10);
+                          if ( *tmp || args->clevel<0 || args->clevel>9 ) error("Could not parse argument: --compression-level %s\n", optarg+1);
+                      }
+                      break;
+            case  1 : args->write_index = 1; break;
+            case 'h':
+            case '?': usage(args); break;
+            default: error("Unknown argument: %s\n", optarg);
+        }
+    }
+
+    if ( optind>=argc )
+    {
+        if ( !isatty(fileno((FILE *)stdin)) ) args->fname = "-";  // reading from stdin
+        else usage(args);
+    }
+    else args->fname = argv[optind];
+
+    init(args);
+    sort_blocks(args);
+    merge_blocks(args);
+    destroy(args);
+
+    return 0;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/amplicon_stats.c.pysam.c

@@ -0,0 +1,1758 @@
+#include "samtools.pysam.h"
+
+/*  stats.c -- This is the former bamcheck integrated into samtools/htslib.
+
+    Copyright (C) 2020-2021 Genome Research Ltd.
+
+    Author: James Bonfield <jkb@sanger.ac.uk>
+
+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.  */
+
+/*
+ * This tool is designed to give "samtools stats" style output, but dedicated
+ * to small amplicon sequencing projects.  It gathers stats on the
+ * distribution of reads across amplicons.
+ */
+
+/*
+ * TODO:
+ * - Cope with multiple references.  What do we do here?  Just request one?
+ * - Permit regions rather than consuming whole file (maybe solves above).
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <getopt.h>
+#include <unistd.h>
+#include <math.h>
+
+#include <htslib/sam.h>
+#include <htslib/khash.h>
+
+#include "samtools.h"
+#include "sam_opts.h"
+#include "bam_ampliconclip.h"
+
+KHASH_MAP_INIT_INT64(tcoord, int64_t)
+KHASH_MAP_INIT_STR(qname, int64_t)
+
+#ifndef MIN
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#endif
+
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+#ifndef ABS
+#define ABS(a) ((a)>=0?(a):-(a))
+#endif
+
+#define TCOORD_MIN_COUNT   10
+#define MAX_AMP 1000       // Default maximum number of amplicons
+#define MAX_AMP_LEN 1000   // Default maximum length of any single amplicon
+#define MAX_PRIMER_PER_AMPLICON 4  // Max primers per LEFT/RIGHT
+#define MAX_DEPTH 5        // Number of different depths permitted
+
+typedef struct {
+    sam_global_args ga;
+    uint32_t flag_require;
+    uint32_t flag_filter;
+    int max_delta;   // Used for matching read to amplicon primer loc
+    int min_depth[MAX_DEPTH]; // Used for coverage; must be >= min_depth deep
+    int use_sample_name;
+    int max_amp;     // Total number of amplicons
+    int max_amp_len; // Maximum length of an individual amplicon
+    double depth_bin;// aggregate depth within this fraction
+    int tlen_adj;    // Adjust tlen by this amount, due to clip but no fixmate
+    FILE *out_fp;
+    char *argv;
+    int tcoord_min_count;
+    int tcoord_bin;
+    int multi_ref;
+} astats_args_t;
+
+typedef struct {
+    int nseq;       // total sequence count
+    int nfiltered;  // sequence filtered
+    int nfailprimer;// count of sequences not matching the primer locations
+
+    // Sizes of memory allocated below, to permit reset
+    int max_amp, max_amp_len, max_len;
+
+    // Summary across all samples, sum(x) plus sum(x^2) for s.d. calc
+    int64_t *nreads, *nreads2;          // [max_amp]
+    double  *nfull_reads;               // [max_amp]; 0.5/read if paired.
+    double  *nrperc, *nrperc2;          // [max_amp]
+    int64_t *nbases, *nbases2;          // [max_amp]
+    int64_t *coverage;                  // [max_amp][max_amp_len]
+    double  (*covered_perc)[MAX_DEPTH]; // [max_amp][MAX_DEPTH]
+    double  (*covered_perc2)[MAX_DEPTH];// [max_amp][MAX_DEPTH];
+    khash_t(tcoord) **tcoord;           // [max_amp+1]
+
+    // 0 is correct pair, 1 is incorrect pair, 2 is unidentified
+    int     (*amp_dist)[3];             // [MAX_AMP][3];
+
+    int *depth_valid; // [max_len]
+    int *depth_all;   // [max_len]
+    khash_t(qname) *qend;  // queryname end, for overlap removal
+} astats_t;
+
+// We can have multiple primers for LEFT / RIGHT, so this
+// permits detection by any compatible combination.
+// One reference:
+typedef struct {
+    int64_t left[MAX_PRIMER_PER_AMPLICON];
+    int nleft;
+    int64_t right[MAX_PRIMER_PER_AMPLICON];
+    int nright;
+    int64_t max_left, min_right; // inner dimensions
+    int64_t min_left, max_right; // outer dimensions
+} amplicon_t;
+
+// Multiple references, we have an array of amplicons_t - one per used ref.
+// We have per reference local and global stats here, as some of the stats
+// are coordinate based.  However we report them combined together as a single
+// list across all references.
+// "namp" is the number of amplicons in this reference, but they're
+// numbered first_amp to first_amp+namp-1 inclusively.
+typedef struct {
+    int tid, namp;
+    int64_t len;
+    bed_entry_list_t *sites;
+    amplicon_t *amp;
+    astats_t *lstats, *gstats; // local (1 file) and global (all file) stats
+    const char *ref;           // ref name (pointer to the bed hash table key)
+    int first_amp;             // first amplicon number for this ref
+} amplicons_t;
+
+// Reinitialised for each new reference/chromosome.
+// Counts from 1 to namp, -1 for no match and 0 for ?.
+static int *pos2start = NULL;
+static int *pos2end = NULL;
+static int pos2size = 0; // allocated size of pos2start/end
+
+// Lookup table to go from position to amplicon based on
+// read start / end.
+static int initialise_amp_pos_lookup(astats_args_t *args,
+                                     amplicons_t *amps,
+                                     int ref) {
+    int64_t i, j;
+    amplicon_t *amp = amps[ref].amp;
+    int64_t max_len = amps[ref].len;
+    int namp = amps[ref].namp;
+
+    if (max_len+1 > pos2size) {
+        if (!(pos2start = realloc(pos2start, (max_len+1)*sizeof(*pos2start))))
+            return -1;
+        if (!(pos2end   = realloc(pos2end,   (max_len+1)*sizeof(*pos2end))))
+            return -1;
+        pos2size = max_len;
+    }
+    for (i = 0; i < max_len; i++)
+        pos2start[i] = pos2end[i] = -1;
+
+    for (i = 0; i < namp; i++) {
+        for (j = 0; j < amp[i].nleft; j++) {
+            int64_t p;
+            for (p = amp[i].left[j] - args->max_delta;
+                 p <= amp[i].left[j] + args->max_delta; p++) {
+                if (p < 1 || p > max_len)
+                    continue;
+                pos2start[p-1] = i;
+            }
+        }
+        for (j = 0; j < amp[i].nright; j++) {
+            int64_t p;
+            for (p = amp[i].right[j] - args->max_delta;
+                 p <= amp[i].right[j] + args->max_delta; p++) {
+                if (p < 1 || p > max_len)
+                    continue;
+                pos2end[p-1] = i;
+            }
+        }
+    }
+
+    return 0;
+}
+
+// Counts amplicons.
+// Assumption: input BED file alternates between LEFT and RIGHT primers
+// per amplicon, thus we can count the number based on the switching
+// orientation.
+static int count_amplicon(bed_entry_list_t *sites) {
+    int i, namp, last_rev = 0;
+    for (i = namp = 0; i < sites->length; i++) {
+        if (sites->bp[i].rev == 0 && last_rev)
+            namp++;
+        last_rev = sites->bp[i].rev;
+    }
+
+    return ++namp;
+}
+
+// We're only interest in the internal part of the amplicon.
+// Our bed file has LEFT start/end followed by RIGHT start/end,
+// so collapse these to LEFT end / RIGHT start.
+//
+// Returns right most amplicon position on success,
+//         < 0 on error
+static int64_t bed2amplicon(astats_args_t *args, bed_entry_list_t *sites,
+                            amplicon_t *amp, int *namp, int do_title,
+                            const char *ref, int first_amp) {
+    int i, j;
+    int64_t max_right = 0;
+    FILE *ofp = args->out_fp;
+
+    *namp = 0;
+
+    // Assume all primers for the same amplicon are adjacent in BED
+    // with all + followed by all -.  Thus - to + signifies next primer set.
+    int last_rev = 0;
+    amp[0].max_left = 0;
+    amp[0].min_right = INT64_MAX;
+    amp[0].min_left = INT64_MAX;
+    amp[0].max_right = 0;
+    if (do_title) {
+        fprintf(ofp, "# Amplicon locations from BED file.\n");
+        fprintf(ofp, "# LEFT/RIGHT are <start>-<end> format and "
+                "comma-separated for alt-primers.\n");
+        if (args->multi_ref)
+            fprintf(ofp, "#\n# AMPLICON\tREF\tNUMBER\tLEFT\tRIGHT\n");
+        else
+            fprintf(ofp, "#\n# AMPLICON\tNUMBER\tLEFT\tRIGHT\n");
+    }
+    for (i = j = 0; i < sites->length; i++) {
+        if (i == 0 && sites->bp[i].rev != 0) {
+            fprintf(samtools_stderr, "[ampliconstats] error: BED file should start"
+                    " with the + strand primer\n");
+            return -1;
+        }
+        if (sites->bp[i].rev == 0 && last_rev) {
+            j++;
+            if (j >= args->max_amp) {
+                fprintf(samtools_stderr, "[ampliconstats] error: too many amplicons"
+                        " (%d). Use -a option to raise this.\n", j);
+                return -1;
+            }
+            amp[j].max_left = 0;
+            amp[j].min_right = INT64_MAX;
+            amp[j].min_left = INT64_MAX;
+            amp[j].max_right = 0;
+        }
+        if (sites->bp[i].rev == 0) {
+            if (i == 0 || last_rev) {
+                if (j>0) fprintf(ofp, "\n");
+                if (args->multi_ref)
+                    fprintf(ofp, "AMPLICON\t%s\t%d", ref, j+1 + first_amp);
+                else
+                    fprintf(ofp, "AMPLICON\t%d", j+1);
+            }
+            if (amp[j].nleft >= MAX_PRIMER_PER_AMPLICON) {
+                print_error_errno("ampliconstats",
+                                  "too many primers per amplicon (%d).\n",
+                                  MAX_PRIMER_PER_AMPLICON);
+                return -1;
+            }
+            amp[j].left[amp[j].nleft++] = sites->bp[i].right;
+            if (amp[j].max_left < sites->bp[i].right+1)
+                amp[j].max_left = sites->bp[i].right+1;
+            if (amp[j].min_left > sites->bp[i].right+1)
+                amp[j].min_left = sites->bp[i].right+1;
+            // BED file, so left+1 as zero based. right(+1-1) as
+            // BED goes one beyond end (and we want inclusive range).
+            fprintf(ofp, "%c%"PRId64"-%"PRId64, "\t,"[amp[j].nleft > 1],
+                    sites->bp[i].left+1, sites->bp[i].right);
+        } else {
+            if (amp[j].nright >= MAX_PRIMER_PER_AMPLICON) {
+                print_error_errno("ampliconstats",
+                                  "too many primers per amplicon (%d)",
+                                  MAX_PRIMER_PER_AMPLICON);
+                return -1;
+            }
+            amp[j].right[amp[j].nright++] = sites->bp[i].left;
+            if (amp[j].min_right > sites->bp[i].left-1)
+                amp[j].min_right = sites->bp[i].left-1;
+            if (amp[j].max_right < sites->bp[i].left-1) {
+                amp[j].max_right = sites->bp[i].left-1;
+                if (amp[j].max_right - amp[j].min_left + 1 >=
+                    args->max_amp_len) {
+                    fprintf(samtools_stderr, "[ampliconstats] error: amplicon "
+                            "longer (%d) than max_amp_len option (%d)\n",
+                            (int)(amp[j].max_right - amp[j].min_left + 2),
+                            args->max_amp_len);
+                    return -1;
+                }
+                if (max_right < amp[j].max_right)
+                    max_right = amp[j].max_right;
+            }
+            fprintf(ofp, "%c%"PRId64"-%"PRId64, "\t,"[amp[j].nright > 1],
+                    sites->bp[i].left+1, sites->bp[i].right);
+        }
+        last_rev = sites->bp[i].rev;
+    }
+    if (last_rev != 1) {
+        fprintf(ofp, "\n"); // useful if going to samtools_stdout
+        fprintf(samtools_stderr, "[ampliconstats] error: bed file does not end on"
+                " a reverse strand primer.\n");
+        return -1;
+    }
+    *namp = ++j;
+    if (j) fprintf(ofp, "\n");
+
+    if (j >= args->max_amp) {
+        fprintf(samtools_stderr, "[ampliconstats] error: "
+                "too many amplicons (%d). Use -a option to raise this.", j);
+        return -1;
+    }
+
+//    for (i = 0; i < *namp; i++) {
+//      fprintf(samtools_stdout, "%d\t%ld", i, amp[i].length);
+//      for (j = 0; j < amp[i].nleft; j++)
+//          fprintf(samtools_stdout, "%c%ld", "\t,"[j>0], amp[i].left[j]);
+//      for (j = 0; j < amp[i].nright; j++)
+//          fprintf(samtools_stdout, "%c%ld", "\t,"[j>0], amp[i].right[j]);
+//      fprintf(samtools_stdout, "\n");
+//    }
+
+    return max_right;
+}
+
+void stats_free(astats_t *st) {
+    if (!st)
+        return;
+
+    free(st->nreads);
+    free(st->nreads2);
+    free(st->nfull_reads);
+    free(st->nrperc);
+    free(st->nrperc2);
+    free(st->nbases);
+    free(st->nbases2);
+    free(st->coverage);
+    free(st->covered_perc);
+    free(st->covered_perc2);
+    free(st->amp_dist);
+
+    free(st->depth_valid);
+    free(st->depth_all);
+
+    if (st->tcoord) {
+        int i;
+        for (i = 0; i <= st->max_amp; i++) {
+            if (st->tcoord[i])
+                kh_destroy(tcoord, st->tcoord[i]);
+        }
+        free(st->tcoord);
+    }
+
+    khiter_t k;
+    for (k = kh_begin(st->qend); k != kh_end(st->qend); k++)
+        if (kh_exist(st->qend, k))
+            free((void *)kh_key(st->qend, k));
+    kh_destroy(qname, st->qend);
+
+    free(st);
+}
+
+astats_t *stats_alloc(int64_t max_len, int max_amp, int max_amp_len) {
+    astats_t *st = calloc(1, sizeof(*st));
+    if (!st)
+        return NULL;
+
+    st->max_amp = max_amp;
+    st->max_amp_len = max_amp_len;
+    st->max_len = max_len;
+
+    if (!(st->nreads  = calloc(max_amp, sizeof(*st->nreads))))  goto err;
+    if (!(st->nreads2 = calloc(max_amp, sizeof(*st->nreads2)))) goto err;
+    if (!(st->nrperc  = calloc(max_amp, sizeof(*st->nrperc))))  goto err;
+    if (!(st->nrperc2 = calloc(max_amp, sizeof(*st->nrperc2)))) goto err;
+    if (!(st->nbases  = calloc(max_amp, sizeof(*st->nbases))))  goto err;
+    if (!(st->nbases2 = calloc(max_amp, sizeof(*st->nbases2)))) goto err;
+
+    if (!(st->nfull_reads = calloc(max_amp, sizeof(*st->nfull_reads))))
+        goto err;
+
+    if (!(st->coverage = calloc(max_amp*max_amp_len, sizeof(*st->coverage))))
+        goto err;
+
+    if (!(st->covered_perc  = calloc(max_amp, sizeof(*st->covered_perc))))
+        goto err;
+    if (!(st->covered_perc2 = calloc(max_amp, sizeof(*st->covered_perc2))))
+        goto err;
+
+    if (!(st->tcoord = calloc(max_amp+1, sizeof(*st->tcoord)))) goto err;
+    int i;
+    for (i = 0; i <= st->max_amp; i++)
+        if (!(st->tcoord[i] = kh_init(tcoord)))
+            goto err;
+
+    if (!(st->qend = kh_init(qname)))
+        goto err;
+
+    if (!(st->depth_valid = calloc(max_len, sizeof(*st->depth_valid))))
+        goto err;
+    if (!(st->depth_all   = calloc(max_len, sizeof(*st->depth_all))))
+        goto err;
+
+    if (!(st->amp_dist  = calloc(max_amp, sizeof(*st->amp_dist))))  goto err;
+
+    return st;
+
+ err:
+    stats_free(st);
+    return NULL;
+}
+
+static void stats_reset(astats_t *st) {
+    st->nseq = 0;
+    st->nfiltered = 0;
+    st->nfailprimer = 0;
+
+    memset(st->nreads,  0, st->max_amp * sizeof(*st->nreads));
+    memset(st->nreads2, 0, st->max_amp * sizeof(*st->nreads2));
+    memset(st->nfull_reads, 0, st->max_amp * sizeof(*st->nfull_reads));
+
+    memset(st->nrperc,  0, st->max_amp * sizeof(*st->nrperc));
+    memset(st->nrperc2, 0, st->max_amp * sizeof(*st->nrperc2));
+
+    memset(st->nbases,  0, st->max_amp * sizeof(*st->nbases));
+    memset(st->nbases2, 0, st->max_amp * sizeof(*st->nbases2));
+
+    memset(st->coverage, 0, st->max_amp * st->max_amp_len
+           * sizeof(*st->coverage));
+    memset(st->covered_perc,  0, st->max_amp * sizeof(*st->covered_perc));
+    memset(st->covered_perc2, 0, st->max_amp * sizeof(*st->covered_perc2));
+
+    // Keep the allocated entries as it's likely all files will share
+    // the same keys.  Instead we reset counters to zero for common ones
+    // and delete rare ones.
+    int i;
+    for (i = 0; i <= st->max_amp; i++) {
+        khiter_t k;
+        for (k = kh_begin(st->tcoord[i]);
+             k != kh_end(st->tcoord[i]); k++)
+            if (kh_exist(st->tcoord[i], k)) {
+                if (kh_value(st->tcoord[i], k) < 5)
+                    kh_del(tcoord, st->tcoord[i], k);
+                else
+                    kh_value(st->tcoord[i], k) = 0;
+            }
+    }
+
+    khiter_t k;
+    for (k = kh_begin(st->qend); k != kh_end(st->qend); k++)
+        if (kh_exist(st->qend, k))
+            free((void *)kh_key(st->qend, k));
+    kh_clear(qname, st->qend);
+
+    memset(st->depth_valid, 0, st->max_len * sizeof(*st->depth_valid));
+    memset(st->depth_all,   0, st->max_len * sizeof(*st->depth_all));
+    memset(st->amp_dist,  0, st->max_amp * sizeof(*st->amp_dist));
+}
+
+static void amp_stats_reset(amplicons_t *amps, int nref) {
+    int i;
+    for (i = 0; i < nref; i++) {
+        if (!amps[i].sites)
+            continue;
+        stats_reset(amps[i].lstats);
+    }
+}
+
+static int accumulate_stats(astats_args_t *args, amplicons_t *amps,
+                            bam1_t *b) {
+    int ref = b->core.tid;
+    amplicon_t *amp = amps[ref].amp;
+    astats_t *stats = amps[ref].lstats;
+    int len = amps[ref].len;
+
+    if (!stats)
+        return 0;
+
+    stats->nseq++;
+    if ((b->core.flag & args->flag_require) != args->flag_require ||
+        (b->core.flag & args->flag_filter)  != 0) {
+        stats->nfiltered++;
+        return 0;
+    }
+
+    int64_t start = b->core.pos, mstart = start; // modified start
+    int64_t end = bam_endpos(b), i;
+
+    // Compute all-template-depth and valid-template-depth.
+    // We track current end location per read name so we can remove overlaps.
+    // Potentially we could use this data for a better amplicon-depth
+    // count too, but for now it's purely for the per-base plots.
+    int ret;
+    khiter_t k;
+    int prev_start = 0, prev_end = 0;
+    if ((b->core.flag & BAM_FPAIRED)
+        && !(b->core.flag & (BAM_FSUPPLEMENTARY | BAM_FSECONDARY))) {
+        k = kh_put(qname, stats->qend, bam_get_qname(b), &ret);
+        if (ret == 0) {
+            prev_start = kh_value(stats->qend, k) & 0xffffffff;
+            prev_end = kh_value(stats->qend, k)>>32;
+            mstart = MAX(mstart, prev_end);
+            // Ideally we'd reuse strings so we don't thrash free/malloc.
+            // However let's see if the official way of doing that (malloc
+            // itself) is fast enough first.
+            free((void *)kh_key(stats->qend, k));
+            kh_del(qname, stats->qend, k);
+            //fprintf(samtools_stderr, "remove overlap %d to %d\n", (int)start, (int)mstart);
+        } else {
+            if (!(kh_key(stats->qend, k) = strdup(bam_get_qname(b))))
+                return -1;
+
+            kh_value(stats->qend, k) = start | (end << 32);
+        }
+    }
+    for (i = mstart; i < end && i < len; i++)
+        stats->depth_all[i]++;
+    if (i < end) {
+        print_error("ampliconstats", "record %s overhangs end of reference",
+                    bam_get_qname(b));
+        // But keep going, as it's harmless.
+    }
+
+    // On single ended runs, eg ONT or PacBio, we just use the start/end
+    // of the template to assign.
+    int anum = (b->core.flag & BAM_FREVERSE) || !(b->core.flag & BAM_FPAIRED)
+        ? (end-1 >= 0 && end-1 < len ? pos2end[end-1] : -1)
+        : (start >= 0 && start < len ? pos2start[start] : -1);
+
+    // ivar sometimes soft-clips 100% of the bases.
+    // This is essentially unmapped
+    if (end == start && (args->flag_filter & BAM_FUNMAP)) {
+        stats->nfiltered++;
+        return 0;
+    }
+
+    if (anum == -1)
+        stats->nfailprimer++;
+
+    if (anum >= 0) {
+        int64_t c = MIN(end,amp[anum].min_right+1) - MAX(start,amp[anum].max_left);
+        if (c > 0) {
+            stats->nreads[anum]++;
+            // NB: ref bases rather than read bases
+            stats->nbases[anum] += c;
+
+            int64_t i;
+            if (start < 0) start = 0;
+            if (end > len) end = len;
+
+            int64_t ostart = MAX(start, amp[anum].min_left-1);
+            int64_t oend = MIN(end, amp[anum].max_right);
+            int64_t offset = amp[anum].min_left-1;
+            for (i = ostart; i < oend; i++)
+                stats->coverage[anum*stats->max_amp_len + i-offset]++;
+        } else {
+            stats->nfailprimer++;
+        }
+    }
+
+    // Template length in terms of amplicon number to amplicon number.
+    // We expect left to right of same amplicon (len 0), but it may go
+    // to next amplicon (len 1) or prev (len -1), etc.
+    int64_t t_end;
+    int oth_anum = -1;
+
+    if (b->core.flag & BAM_FPAIRED) {
+        t_end = (b->core.flag & BAM_FREVERSE ? end : start)
+            + b->core.isize;
+
+        // If we've clipped the primers but not followed up with a fixmates
+        // then our start+TLEN will take us to a location which is
+        // length(LEFT_PRIMER) + length(RIGHT_PRIMER) too far away.
+        //
+        // The correct solution is to run samtools fixmate so TLEN is correct.
+        // The hacky solution is to fudge the expected tlen by double the
+        // average primer length (e.g. 50).
+        t_end += b->core.isize > 0 ? -args->tlen_adj : +args->tlen_adj;
+
+        if (t_end > 0 && t_end < len && b->core.isize != 0)
+            oth_anum = (b->core.flag & BAM_FREVERSE)
+                ? pos2start[t_end]
+                : pos2end[t_end];
+    } else {
+        // Not paired (see int anum = (REV || !PAIR) ?en :st expr above)
+        oth_anum = pos2start[start];
+        t_end = end;
+    }
+
+    // We don't want to count our pairs twice.
+    // If both left/right are known, count it on left only.
+    // If only one is known, we'll only get to this code once
+    // so we can also count it.
+    int astatus = 2;
+    if (anum != -1 && oth_anum != -1) {
+        astatus = oth_anum == anum ? 0 : 1;
+        if (start <= t_end)
+            stats->amp_dist[anum][astatus]++;
+    } else if (anum >= 0) {
+        stats->amp_dist[anum][astatus = 2]++;
+    }
+
+    if (astatus == 0 && !(b->core.flag & (BAM_FUNMAP | BAM_FMUNMAP))) {
+        if (prev_end && mstart > prev_end) {
+            // 2nd read with gap to 1st; undo previous increment.
+            for (i = prev_start; i < prev_end; i++)
+                stats->depth_valid[i]--;
+            stats->nfull_reads[anum] -= (b->core.flag & BAM_FPAIRED) ? 0.5 : 1;
+        } else {
+            // 1st read, or 2nd read that overlaps 1st
+            for (i = mstart; i < end; i++)
+                stats->depth_valid[i]++;
+            stats->nfull_reads[anum] += (b->core.flag & BAM_FPAIRED) ? 0.5 : 1;
+        }
+    }
+
+    // Track template start,end frequencies, so we can give stats on
+    // amplicon primer usage.
+    if ((b->core.flag & BAM_FPAIRED) && b->core.isize <= 0)
+        // left to right only, so we don't double count template positions.
+        return 0;
+
+    start = b->core.pos;
+    t_end = b->core.flag & BAM_FPAIRED
+        ? start + b->core.isize-1
+        : end;
+    uint64_t tcoord = MIN(start+1, UINT32_MAX) | (MIN(t_end+1, UINT32_MAX)<<32);
+    k = kh_put(tcoord, stats->tcoord[anum+1], tcoord, &ret);
+    if (ret < 0)
+        return -1;
+    if (ret == 0)
+        kh_value(stats->tcoord[anum+1], k)++;
+    else
+        kh_value(stats->tcoord[anum+1], k)=1;
+    kh_value(stats->tcoord[anum+1], k) |= ((int64_t)astatus<<32);
+
+    return 0;
+}
+
+// Append file local stats to global stats
+int append_lstats(astats_t *lstats, astats_t *gstats, int namp, int all_nseq) {
+    gstats->nseq += lstats->nseq;
+    gstats->nfiltered += lstats->nfiltered;
+    gstats->nfailprimer += lstats->nfailprimer;
+
+    int a;
+    for (a = -1; a < namp; a++) {
+        // Add khash local (kl) to khash global (kg)
+        khiter_t kl, kg;
+        for (kl = kh_begin(lstats->tcoord[a+1]);
+             kl != kh_end(lstats->tcoord[a+1]); kl++) {
+            if (!kh_exist(lstats->tcoord[a+1], kl) ||
+                kh_value(lstats->tcoord[a+1], kl) == 0)
+                continue;
+
+            int ret;
+            kg = kh_put(tcoord, gstats->tcoord[a+1],
+                        kh_key(lstats->tcoord[a+1], kl),
+                        &ret);
+            if (ret < 0)
+                return -1;
+
+            kh_value(gstats->tcoord[a+1], kg) =
+                (ret == 0
+                 ? (kh_value(gstats->tcoord[a+1], kg) & 0xFFFFFFFF)
+                 : 0)
+                + kh_value(lstats->tcoord[a+1], kl);
+        }
+        if (a == -1) continue;
+
+        gstats->nreads[a]  += lstats->nreads[a];
+        gstats->nreads2[a] += lstats->nreads[a] * lstats->nreads[a];
+        gstats->nfull_reads[a] += lstats->nfull_reads[a];
+
+        // To get mean & sd for amplicon read percentage, we need
+        // to do the divisions here as nseq differs for each sample.
+        double nrperc = all_nseq ? 100.0 * lstats->nreads[a] / all_nseq : 0;
+        gstats->nrperc[a]  += nrperc;
+        gstats->nrperc2[a] += nrperc*nrperc;
+
+        gstats->nbases[a]  += lstats->nbases[a];
+        gstats->nbases2[a] += lstats->nbases[a] * lstats->nbases[a];
+
+        int d;
+        for (d = 0; d < MAX_DEPTH; d++) {
+            gstats->covered_perc[a][d]  += lstats->covered_perc[a][d];
+            gstats->covered_perc2[a][d] += lstats->covered_perc[a][d]
+                                         * lstats->covered_perc[a][d];
+        }
+
+        for (d = 0; d < 3; d++)
+            gstats->amp_dist[a][d] += lstats->amp_dist[a][d];
+    }
+
+    for (a = 0; a < lstats->max_len; a++) {
+        gstats->depth_valid[a] += lstats->depth_valid[a];
+        gstats->depth_all[a]   += lstats->depth_all[a];
+    }
+
+    return 0;
+}
+
+int append_stats(amplicons_t *amps, int nref) {
+    int i, r, all_nseq = 0;
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = amps[r].lstats;
+        all_nseq  += stats->nseq - stats->nfiltered - stats->nfailprimer;
+    }
+
+    for (i = 0; i < nref; i++) {
+        if (!amps[i].sites)
+            continue;
+        if (append_lstats(amps[i].lstats, amps[i].gstats, amps[i].namp,
+                          all_nseq) < 0)
+            return -1;
+    }
+
+    return 0;
+}
+
+typedef struct {
+    int32_t start, end;
+    uint32_t freq;
+    uint32_t status;
+} tcoord_t;
+
+// Sort tcoord by descending frequency and then ascending start and  end.
+static int tcoord_freq_sort(const void *vp1, const void *vp2) {
+    const tcoord_t *t1 = (const tcoord_t *)vp1;
+    const tcoord_t *t2 = (const tcoord_t *)vp2;
+
+    if (t1->freq != t2->freq)
+        return t2->freq - t1->freq;
+
+    if (t1->start != t2->start)
+        return t1->start - t2->start;
+
+    return t1->end - t2->end;
+}
+
+
+/*
+ * Merges tcoord start,end,freq,status tuples if their coordinates are
+ * close together.  We aim to keep the start,end for the most frequent
+ * value and assume that is the correct coordinate and all others are
+ * minor fluctuations due to errors or variants.
+ *
+ * We sort by frequency first and then merge later items in the list into
+ * the earlier more frequent ones.  It's O(N^2), but sufficient for now
+ * given current scale of projects.
+ *
+ * If we ever need to resolve that then consider sorting by start
+ * coordinate and scanning the list to find all items within X, find
+ * the most frequent of those, and then cluster that way.  (I'd have
+ * done that had I thought of it at the time!)
+ */
+static void aggregate_tcoord(astats_args_t *args, tcoord_t *tpos, size_t *np){
+    size_t n = *np, j, j2, j3, k;
+
+    // Sort by frequency and cluster infrequent coords into frequent
+    // ones provided they're close by.
+    // This is O(N^2), but we've already binned by tcoord_bin/2 so
+    // the list isn't intended to be vast at this point.
+    qsort(tpos, n, sizeof(*tpos), tcoord_freq_sort);
+
+    // For frequency ties, find mid start coord, and then find mid end
+    // coord of those matching start.
+    // We make that the first item so we merge into that mid point.
+    for (j = 0; j < n; j++) {
+        for (j2 = j+1; j2 < n; j2++) {
+            if (tpos[j].freq != tpos[j2].freq)
+                break;
+            if (tpos[j2].start - tpos[j].start >= args->tcoord_bin)
+                break;
+        }
+
+        // j to j2 all within bin of a common start,
+        // m is the mid start.
+        if (j2-1 > j) {
+            size_t m = (j2-1 + j)/2;
+
+            // Find mid end for this same start
+            while (m > 1 && tpos[m].start == tpos[m-1].start)
+                m--;
+            for (j3 = m+1; j3 < j2; j3++) {
+                if (tpos[m].start != tpos[j3].start)
+                    break;
+                if (tpos[m].end - tpos[j3].end >= args->tcoord_bin)
+                    break;
+            }
+            if (j3-1 > m)
+                m = (j3-1 + m)/2;
+
+            // Swap with first item.
+            tcoord_t tmp = tpos[j];
+            tpos[j] = tpos[m];
+            tpos[m] = tmp;
+            j = j2-1;
+        }
+    }
+
+    // Now merge in coordinates.
+    // This bit is O(N^2), so consider binning first to reduce the
+    // size of the list if we have excessive positional variation.
+    for (k = j = 0; j < n; j++) {
+        if (!tpos[j].freq)
+            continue;
+
+        if (k < j)
+            tpos[k] = tpos[j];
+
+        for (j2 = j+1; j2 < n; j2++) {
+            if (ABS(tpos[j].start-tpos[j2].start) < args->tcoord_bin/2 &&
+                ABS(tpos[j].end  -tpos[j2].end)  < args->tcoord_bin/2 &&
+                tpos[j].status == tpos[j2].status) {
+                tpos[k].freq += tpos[j2].freq;
+                tpos[j2].freq = 0;
+            }
+        }
+        k++;
+    }
+
+    *np = k;
+}
+
+int dump_stats(astats_args_t *args, char type, char *name, int nfile,
+               amplicons_t *amps, int nref, int local) {
+    int i, r;
+    FILE *ofp = args->out_fp;
+    tcoord_t *tpos = NULL;
+    size_t ntcoord = 0;
+
+    // summary stats for this sample (or for all samples)
+    fprintf(ofp, "# Summary stats.\n");
+    fprintf(ofp, "# Use 'grep ^%cSS | cut -f 2-' to extract this part.\n", type);
+
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        int nmatch = stats->nseq - stats->nfiltered - stats->nfailprimer;
+        char *name_ref = malloc(strlen(name) + strlen(amps[r].ref) + 2);
+        if (!name_ref)
+            return -1;
+        if (args->multi_ref)
+            sprintf(name_ref, "%s\t%s", name, amps[r].ref);
+        else
+            sprintf(name_ref, "%s", name);
+        fprintf(ofp, "%cSS\t%s\traw total sequences:\t%d\n",
+                type, name_ref, stats->nseq);
+        fprintf(ofp, "%cSS\t%s\tfiltered sequences:\t%d\n",
+                type, name_ref, stats->nfiltered);
+        fprintf(ofp, "%cSS\t%s\tfailed primer match:\t%d\n",
+                type, name_ref, stats->nfailprimer);
+        fprintf(ofp, "%cSS\t%s\tmatching sequences:\t%d\n",
+                type, name_ref, nmatch);
+
+        int d = 0;
+        do {
+            // From first to last amplicon only, so not entire consensus.
+            // If contig length is known, maybe we want to add the missing
+            // count to < DEPTH figures?
+            int64_t start = 0, covered = 0, total = 0;
+            amplicon_t *amp = amps[r].amp;
+            for (i = 0; i < amps[r].namp; i++) {
+                int64_t j, offset = amp[i].min_left-1;
+                if (amp[i].min_right - amp[i].min_left > stats->max_amp_len) {
+                    fprintf(samtools_stderr, "[ampliconstats] error: "
+                            "Maximum amplicon length (%d) exceeded for '%s'\n",
+                            stats->max_amp, name);
+                    return -1;
+                }
+                for (j = MAX(start, amp[i].max_left-1);
+                     j < MAX(start, amp[i].min_right); j++) {
+                    if (stats->coverage[i*stats->max_amp_len + j-offset]
+                        >= args->min_depth[d])
+                        covered++;
+                    total++;
+                }
+                start = MAX(start, amp[i].min_right);
+            }
+            fprintf(ofp, "%cSS\t%s\tconsensus depth count < %d and >= %d:\t%"
+                    PRId64"\t%"PRId64"\n", type, name_ref,
+                    args->min_depth[d], args->min_depth[d],
+                    total-covered, covered);
+        } while (++d < MAX_DEPTH && args->min_depth[d]);
+
+        free(name_ref);
+    }
+
+    // Read count
+    fprintf(ofp, "# Absolute matching read counts per amplicon.\n");
+    fprintf(ofp, "# Use 'grep ^%cREADS | cut -f 2-' to extract this part.\n", type);
+    fprintf(ofp, "%cREADS\t%s", type, name);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0; i < amps[r].namp; i++) {
+            fprintf(ofp, "\t%"PRId64, stats->nreads[i]);
+        }
+    }
+    fprintf(ofp, "\n");
+
+    // Valid depth is the number of full length reads (already divided
+    // by the number we expect to cover), so +0.5 per read in pair.
+    // A.k.a "usable depth" in the plots.
+    fprintf(ofp, "%cVDEPTH\t%s", type, name);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0; i < amps[r].namp; i++)
+            fprintf(ofp, "\t%d", (int)stats->nfull_reads[i]);
+    }
+    fprintf(ofp, "\n");
+
+    if (type == 'C') {
+        // For combined we can compute mean & standard deviation too
+        fprintf(ofp, "CREADS\tMEAN");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            for (i = 0; i < amps[r].namp; i++) {
+                fprintf(ofp, "\t%.1f", stats->nreads[i] / (double)nfile);
+            }
+        }
+        fprintf(ofp, "\n");
+
+        fprintf(ofp, "CREADS\tSTDDEV");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            for (i = 0; i < amps[r].namp; i++) {
+                double n1 = stats->nreads[i];
+                fprintf(ofp, "\t%.1f", nfile > 1 && stats->nreads2[i] > 0
+                        ? sqrt(stats->nreads2[i]/(double)nfile
+                               - (n1/nfile)*(n1/nfile))
+                        : 0);
+            }
+        }
+        fprintf(ofp, "\n");
+    }
+
+    fprintf(ofp, "# Read percentage of distribution between amplicons.\n");
+    fprintf(ofp, "# Use 'grep ^%cRPERC | cut -f 2-' to extract this part.\n", type);
+    fprintf(ofp, "%cRPERC\t%s", type, name);
+    int all_nseq = 0;
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        all_nseq  += stats->nseq - stats->nfiltered - stats->nfailprimer;
+    }
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0; i < amps[r].namp; i++) {
+            if (type == 'C') {
+                fprintf(ofp, "\t%.3f", (double)stats->nrperc[i] / nfile);
+            } else {
+                fprintf(ofp, "\t%.3f",
+                        all_nseq ? 100.0 * stats->nreads[i] / all_nseq : 0);
+            }
+        }
+    }
+    fprintf(ofp, "\n");
+
+    if (type == 'C') {
+        // For combined we compute mean and standard deviation too
+        fprintf(ofp, "CRPERC\tMEAN");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            for (i = 0; i < amps[r].namp; i++) {
+                fprintf(ofp, "\t%.3f", stats->nrperc[i] / nfile);
+            }
+        }
+        fprintf(ofp, "\n");
+
+        fprintf(ofp, "CRPERC\tSTDDEV");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            for (i = 0; i < amps[r].namp; i++) {
+                // variance = SUM(X^2) - ((SUM(X)^2) / N)
+                double n1 = stats->nrperc[i];
+                double v = stats->nrperc2[i]/nfile - (n1/nfile)*(n1/nfile);
+                fprintf(ofp, "\t%.3f", v>0?sqrt(v):0);
+            }
+        }
+        fprintf(ofp, "\n");
+    }
+
+    // Base depth
+    fprintf(ofp, "# Read depth per amplicon.\n");
+    fprintf(ofp, "# Use 'grep ^%cDEPTH | cut -f 2-' to extract this part.\n", type);
+    fprintf(ofp, "%cDEPTH\t%s", type, name);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        amplicon_t *amp = amps[r].amp;
+        for (i = 0; i < amps[r].namp; i++) {
+            int nseq = stats->nseq - stats->nfiltered - stats->nfailprimer;
+            int64_t alen = amp[i].min_right - amp[i].max_left+1;
+            fprintf(ofp, "\t%.1f", nseq ? stats->nbases[i] / (double)alen : 0);
+        }
+    }
+    fprintf(ofp, "\n");
+
+    if (type == 'C') {
+        // For combined we can compute mean & standard deviation too
+        fprintf(ofp, "CDEPTH\tMEAN");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            amplicon_t *amp = amps[r].amp;
+            int nseq = stats->nseq - stats->nfiltered - stats->nfailprimer;
+            for (i = 0; i < amps[r].namp; i++) {
+                int64_t alen = amp[i].min_right - amp[i].max_left+1;
+                fprintf(ofp, "\t%.1f", nseq ? stats->nbases[i] / (double)alen / nfile : 0);
+            }
+        }
+        fprintf(ofp, "\n");
+
+        fprintf(ofp, "CDEPTH\tSTDDEV");
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+            amplicon_t *amp = amps[r].amp;
+            for (i = 0; i < amps[r].namp; i++) {
+                double alen = amp[i].min_right - amp[i].max_left+1;
+                double n1 = stats->nbases[i] / alen;
+                double v = stats->nbases2[i] / (alen*alen) /nfile
+                    - (n1/nfile)*(n1/nfile);
+                fprintf(ofp, "\t%.1f", v>0?sqrt(v):0);
+            }
+        }
+        fprintf(ofp, "\n");
+    }
+
+    // Percent Coverage
+    if (type == 'F') {
+        fprintf(ofp, "# Percentage coverage per amplicon\n");
+        fprintf(ofp, "# Use 'grep ^%cPCOV | cut -f 2-' to extract this part.\n", type);
+        int d = 0;
+        do {
+            fprintf(ofp, "%cPCOV-%d\t%s", type, args->min_depth[d], name);
+
+            for (r = 0; r < nref; r++) {
+                if (!amps[r].sites)
+                    continue;
+                astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+                amplicon_t *amp = amps[r].amp;
+                for (i = 0; i < amps[r].namp; i++) {
+                    int covered = 0;
+                    if (amp[i].min_right - amp[i].min_left > stats->max_amp_len) {
+                        fprintf(samtools_stderr, "[ampliconstats] error: "
+                                "Maximum amplicon length (%d) exceeded for '%s'\n",
+                                stats->max_amp, name);
+                        return -1;
+                    }
+                    int64_t j, offset = amp[i].min_left-1;
+                    for (j = amp[i].max_left-1; j < amp[i].min_right; j++) {
+                        int apos = i*stats->max_amp_len + j-offset;
+                        if (stats->coverage[apos] >= args->min_depth[d])
+                            covered++;
+                    }
+                    int64_t alen = amp[i].min_right - amp[i].max_left+1;
+                    stats->covered_perc[i][d] = 100.0 * covered / alen;
+                    fprintf(ofp, "\t%.2f", 100.0 * covered / alen);
+                }
+            }
+            fprintf(ofp, "\n");
+        } while (++d < MAX_DEPTH && args->min_depth[d]);
+
+    } else if (type == 'C') {
+        // For combined we can compute mean & standard deviation too
+        int d = 0;
+        do {
+            fprintf(ofp, "CPCOV-%d\tMEAN", args->min_depth[d]);
+            for (r = 0; r < nref; r++) {
+                if (!amps[r].sites)
+                    continue;
+                astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+                for (i = 0; i < amps[r].namp; i++) {
+                    fprintf(ofp, "\t%.1f", stats->covered_perc[i][d] / nfile);
+                }
+            }
+            fprintf(ofp, "\n");
+
+            fprintf(ofp, "CPCOV-%d\tSTDDEV", args->min_depth[d]);
+            for (r = 0; r < nref; r++) {
+                if (!amps[r].sites)
+                    continue;
+                astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+                for (i = 0; i < amps[r].namp; i++) {
+                    double n1 = stats->covered_perc[i][d] / nfile;
+                    double v = stats->covered_perc2[i][d] / nfile - n1*n1;
+                    fprintf(ofp, "\t%.1f", v>0?sqrt(v):0);
+                }
+            }
+            fprintf(ofp, "\n");
+        } while (++d < MAX_DEPTH && args->min_depth[d]);
+    }
+
+    // Plus base depth for all reads, irrespective of amplicon.
+    // This is post overlap removal, if reads in the read-pair overlap.
+    fprintf(ofp, "# Depth per reference base for ALL data.\n");
+    fprintf(ofp, "# Use 'grep ^%cDP_ALL | cut -f 2-' to extract this part.\n",
+            type);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        if (args->multi_ref)
+            fprintf(ofp, "%cDP_ALL\t%s\t%s", type, name, amps[r].ref);
+        else
+            fprintf(ofp, "%cDP_ALL\t%s", type, name);
+
+        for (i = 0; i < amps[r].len; i++) {
+            // Basic run-length encoding provided all values are within
+            // +- depth_bin fraction of the mid-point.
+            int dmin = stats->depth_all[i], dmax = stats->depth_all[i], j;
+            double dmid = (dmin + dmax)/2.0;
+            double low  = dmid*(1-args->depth_bin);
+            double high = dmid*(1+args->depth_bin);
+            for (j = i+1; j < amps[r].len; j++) {
+                int d = stats->depth_all[j];
+                if (d < low || d > high)
+                    break;
+                if (dmin > d) {
+                    dmin = d;
+                    dmid = (dmin + dmax)/2.0;
+                    low  = dmid*(1-args->depth_bin);
+                    high = dmid*(1+args->depth_bin);
+                } else if (dmax < d) {
+                    dmax = d;
+                    dmid = (dmin + dmax)/2.0;
+                    low  = dmid*(1-args->depth_bin);
+                    high = dmid*(1+args->depth_bin);
+                }
+            }
+            fprintf(ofp, "\t%d,%d", (int)dmid, j-i);
+            i = j-1;
+        }
+        fprintf(ofp, "\n");
+    }
+
+    // And depth for only reads matching to a single amplicon for full
+    // length.  This is post read overlap removal.
+    fprintf(ofp, "# Depth per reference base for full-length valid amplicon data.\n");
+    fprintf(ofp, "# Use 'grep ^%cDP_VALID | cut -f 2-' to extract this "
+            "part.\n", type);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        if (args->multi_ref)
+            fprintf(ofp, "%cDP_VALID\t%s\t%s", type, name, amps[r].ref);
+        else
+            fprintf(ofp, "%cDP_VALID\t%s", type, name);
+
+        for (i = 0; i < amps[r].len; i++) {
+            int dmin = stats->depth_valid[i], dmax = stats->depth_valid[i], j;
+            double dmid = (dmin + dmax)/2.0;
+            double low  = dmid*(1-args->depth_bin);
+            double high = dmid*(1+args->depth_bin);
+            for (j = i+1; j < amps[r].len; j++) {
+                int d = stats->depth_valid[j];
+                if (d < low || d > high)
+                    break;
+                if (dmin > d) {
+                    dmin = d;
+                    dmid = (dmin + dmax)/2.0;
+                    low  = dmid*(1-args->depth_bin);
+                    high = dmid*(1+args->depth_bin);
+                } else if (dmax < d) {
+                    dmax = d;
+                    dmid = (dmin + dmax)/2.0;
+                    low  = dmid*(1-args->depth_bin);
+                    high = dmid*(1+args->depth_bin);
+                }
+            }
+            fprintf(ofp, "\t%d,%d", (int)dmid, j-i);
+            i = j-1;
+        }
+        fprintf(ofp, "\n");
+    }
+
+    // TCOORD (start to end) distribution
+    fprintf(ofp, "# Distribution of aligned template coordinates.\n");
+    fprintf(ofp, "# Use 'grep ^%cTCOORD | cut -f 2-' to extract this part.\n", type);
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0 - (nref==1); i < amps[r].namp; i++) {
+            if (ntcoord < kh_size(stats->tcoord[i+1])) {
+                ntcoord = kh_size(stats->tcoord[i+1]);
+                tcoord_t *tmp = realloc(tpos, ntcoord * sizeof(*tmp));
+                if (!tmp) {
+                    free(tpos);
+                    return -1;
+                }
+                tpos = tmp;
+            }
+
+            khiter_t k;
+            size_t n = 0, j;
+            for (k = kh_begin(stats->tcoord[i+1]);
+                 k != kh_end(stats->tcoord[i+1]); k++) {
+                if (!kh_exist(stats->tcoord[i+1], k) ||
+                    (kh_value(stats->tcoord[i+1], k) & 0xFFFFFFFF) == 0)
+                    continue;
+                // Key is start,end in 32-bit quantities.
+                // Yes this limits us to 4Gb references, but just how
+                // many primers are we planning on making?  Not that many
+                // I hope.
+                tpos[n].start = kh_key(stats->tcoord[i+1], k)&0xffffffff;
+                tpos[n].end   = kh_key(stats->tcoord[i+1], k)>>32;
+
+                // Value is frequency (top 32-bits) and status (bottom 32).
+                tpos[n].freq   = kh_value(stats->tcoord[i+1], k)&0xffffffff;
+                tpos[n].status = kh_value(stats->tcoord[i+1], k)>>32;
+                n++;
+            }
+
+            if (args->tcoord_bin > 1)
+                aggregate_tcoord(args, tpos, &n);
+
+            fprintf(ofp, "%cTCOORD\t%s\t%d", type, name,
+                    i+1+amps[r].first_amp); // per amplicon
+            for (j = 0; j < n; j++) {
+                if (tpos[j].freq < args->tcoord_min_count)
+                    continue;
+                fprintf(ofp, "\t%d,%d,%u,%u",
+                        tpos[j].start,
+                        tpos[j].end,
+                        tpos[j].freq,
+                        tpos[j].status);
+            }
+            fprintf(ofp, "\n");
+        }
+    }
+
+
+    // AMP length distribution.
+    // 0 = both ends in this amplicon
+    // 1 = ends in different amplicons
+    // 2 = other end matching an unknown amplicon site
+    //     (see tcoord for further analysis of where)
+    fprintf(ofp, "# Classification of amplicon status.  Columns are\n");
+    fprintf(ofp, "# number with both primers from this amplicon, number with\n");
+    fprintf(ofp, "# primers from different amplicon, and number with a position\n");
+    fprintf(ofp, "# not matching any valid amplicon primer site\n");
+    fprintf(ofp, "# Use 'grep ^%cAMP | cut -f 2-' to extract this part.\n", type);
+
+    fprintf(ofp, "%cAMP\t%s\t0", type, name); // all merged
+    int amp_dist[3] = {0};
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0; i < amps[r].namp; i++) { // accumulate for all amps
+            amp_dist[0] += stats->amp_dist[i][0];
+            amp_dist[1] += stats->amp_dist[i][1];
+            amp_dist[2] += stats->amp_dist[i][2];
+        }
+    }
+    fprintf(ofp, "\t%d\t%d\t%d\n", amp_dist[0], amp_dist[1], amp_dist[2]);
+
+    for (r = 0; r < nref; r++) {
+        if (!amps[r].sites)
+            continue;
+        astats_t *stats = local ? amps[r].lstats : amps[r].gstats;
+        for (i = 0; i < amps[r].namp; i++) {
+            // per amplicon
+            fprintf(ofp, "%cAMP\t%s\t%d", type, name, i+1+amps[r].first_amp);
+            fprintf(ofp, "\t%d\t%d\t%d\n", stats->amp_dist[i][0],
+                    stats->amp_dist[i][1], stats->amp_dist[i][2]);
+        }
+    }
+
+    free(tpos);
+    return 0;
+}
+
+int dump_lstats(astats_args_t *args, char type, char *name, int nfile,
+               amplicons_t *amps, int nref) {
+    return dump_stats(args, type, name, nfile, amps, nref, 1);
+}
+
+int dump_gstats(astats_args_t *args, char type, char *name, int nfile,
+               amplicons_t *amps, int nref) {
+    return dump_stats(args, type, name, nfile, amps, nref, 0);
+}
+
+char const *get_sample_name(sam_hdr_t *header, char *RG) {
+    kstring_t ks = {0};
+    sam_hdr_find_tag_id(header, "RG", RG?"ID":NULL, RG, "SM", &ks);
+    return ks.s;
+}
+
+// Return maximum reference length (SQ is NULL) or the length
+// of the specified reference in SQ.
+int64_t get_ref_len(sam_hdr_t *header, const char *SQ) {
+    if (SQ) {
+        int tid = SQ ? sam_hdr_name2tid(header, SQ) : 0;
+        return tid >= 0 ? sam_hdr_tid2len(header, tid) : -1;
+    } else {
+        int nref = sam_hdr_nref(header), tid;;
+        int64_t len = 0;
+        for (tid = 0; tid < nref; tid++) {
+            int64_t rl = sam_hdr_tid2len(header, tid);
+            if (len < rl)
+                len = rl;
+        }
+        return len;
+    }
+}
+
+static int amplicon_stats(astats_args_t *args,
+                          khash_t(bed_list_hash) *bed_hash,
+                          char **filev, int filec) {
+    int i, ref = -1, ref_tid = -1, ret = -1, nref = 0;
+    samFile *fp = NULL;
+    sam_hdr_t *header = NULL;
+    bam1_t *b = bam_init1();
+    FILE *ofp = args->out_fp;
+    char sname_[8192], *sname = NULL;
+    amplicons_t *amps = NULL;
+
+    // Report initial SS header.  We gather data from the bed_hash entries
+    // as well as from the first SAM header (with the requirement that all
+    // headers should be compatible).
+    if (filec) {
+        if (!(fp = sam_open_format(filev[0], "r", &args->ga.in))) {
+            print_error_errno("ampliconstats",
+                              "Cannot open input file \"%s\"",
+                              filev[0]);
+            goto err;
+        }
+        if (!(header = sam_hdr_read(fp)))
+            goto err;
+
+        if (!amps) {
+            amps = calloc(nref=sam_hdr_nref(header), sizeof(*amps));
+            if (!amps)
+                goto err;
+            fprintf(ofp, "# Summary statistics, used for scaling the plots.\n");
+            fprintf(ofp, "SS\tSamtools version: %s\n", samtools_version());
+            fprintf(ofp, "SS\tCommand line: %s\n", args->argv);
+            fprintf(ofp, "SS\tNumber of files:\t%d\n", filec);
+
+            // Note: order of hash entries will be different to order of
+            // BED file which may also differ to order of SQ headers.
+            // SQ header is canonical ordering (pos sorted file).
+            khiter_t k;
+            int bam_nref = sam_hdr_nref(header);
+            for (i = 0; i < bam_nref; i++) {
+                k = kh_get(bed_list_hash, bed_hash,
+                           sam_hdr_tid2name(header, i));
+                if (!kh_exist(bed_hash, k))
+                    continue;
+
+                bed_entry_list_t *sites = &kh_value(bed_hash, k);
+
+                ref = i;
+                amps[ref].ref = kh_key(bed_hash, k);
+                amps[ref].sites = sites;
+                amps[ref].namp = count_amplicon(sites);
+                amps[ref].amp  = calloc(sites->length,
+                                        sizeof(*amps[ref].amp));
+                if (!amps[ref].amp)
+                    goto err;
+                if (args->multi_ref)
+                    fprintf(ofp, "SS\tNumber of amplicons:\t%s\t%d\n",
+                            kh_key(bed_hash, k), amps[ref].namp);
+                else
+                    fprintf(ofp, "SS\tNumber of amplicons:\t%d\n",
+                            amps[ref].namp);
+
+                amps[ref].tid = ref;
+                if (ref_tid == -1)
+                    ref_tid = ref;
+
+                int64_t len = get_ref_len(header, kh_key(bed_hash, k));
+                amps[ref].len = len;
+                if (args->multi_ref)
+                    fprintf(ofp, "SS\tReference length:\t%s\t%"PRId64"\n",
+                            kh_key(bed_hash, k), len);
+                else
+                    fprintf(ofp, "SS\tReference length:\t%"PRId64"\n",
+                            len);
+
+                amps[ref].lstats = stats_alloc(len, args->max_amp,
+                                               args->max_amp_len);
+                amps[ref].gstats = stats_alloc(len, args->max_amp,
+                                               args->max_amp_len);
+                if (!amps[ref].lstats || !amps[ref].gstats)
+                    goto err;
+            }
+        }
+
+        sam_hdr_destroy(header);
+        header = NULL;
+        if (sam_close(fp) < 0) {
+            fp = NULL;
+            goto err;
+        }
+        fp = NULL;
+    }
+    fprintf(ofp, "SS\tEnd of summary\n");
+
+    // Extract the bits of amplicon data we need from bed hash and turn
+    // it into a position-to-amplicon lookup table.
+    int offset = 0;
+    for (i = 0; i < nref; i++) {
+        if (!amps[i].sites)
+            continue;
+
+        amps[i].first_amp = offset;
+        if (bed2amplicon(args, amps[i].sites, amps[i].amp,
+                         &amps[i].namp, i==0, amps[i].ref, offset) < 0)
+            goto err;
+
+        offset += amps[i].namp; // cumulative amplicon number across refs
+    }
+
+    // Now iterate over file contents, one at a time.
+    for (i = 0; i < filec; i++) {
+        char *nstart = filev[i];
+
+        fp = sam_open_format(filev[i], "r", &args->ga.in);
+        if (!fp) {
+            print_error_errno("ampliconstats",
+                              "Cannot open input file \"%s\"",
+                              filev[i]);
+            goto err;
+        }
+
+        if (args->ga.nthreads > 0)
+            hts_set_threads(fp, args->ga.nthreads);
+
+        if (!(header = sam_hdr_read(fp)))
+            goto err;
+
+        if (nref != sam_hdr_nref(header)) {
+            print_error_errno("ampliconstats",
+                              "SAM headers are not consistent across input files");
+            goto err;
+        }
+        int r;
+        for (r = 0; r < nref; r++) {
+            if (!amps[r].sites)
+                continue;
+            if (!amps[r].ref ||
+                strcmp(amps[r].ref, sam_hdr_tid2name(header, r)) != 0 ||
+                amps[r].len != sam_hdr_tid2len(header, r)) {
+                print_error_errno("ampliconstats",
+                                  "SAM headers are not consistent across "
+                                  "input files");
+                goto err;
+            }
+        }
+
+        if (args->use_sample_name)
+            sname = (char *)get_sample_name(header, NULL);
+
+        if (!sname) {
+            sname = sname_;
+            char *nend = filev[i] + strlen(filev[i]), *cp;
+            if ((cp = strrchr(filev[i], '/')))
+                nstart = cp+1;
+            if ((cp = strrchr(nstart, '.')) &&
+                (strcmp(cp, ".bam") == 0 ||
+                 strcmp(cp, ".sam") == 0 ||
+                 strcmp(cp, ".cram") == 0))
+                nend = cp;
+            if (nend - nstart >= 8192) nend = nstart+8191;
+            memcpy(sname, nstart, nend-nstart);
+            sname[nend-nstart] = 0;
+        }
+
+        // Stats local to this sample only
+        amp_stats_reset(amps, nref);
+
+        int last_ref = -9;
+        while ((r = sam_read1(fp, header, b)) >= 0) {
+            // Other filter options useful here?
+            if (b->core.tid < 0)
+                continue;
+
+            if (last_ref != b->core.tid) {
+                last_ref  = b->core.tid;
+                if (initialise_amp_pos_lookup(args, amps, last_ref) < 0)
+                    goto err;
+            }
+
+            if (accumulate_stats(args, amps, b) < 0)
+                goto err;
+        }
+
+        if (r < -1) {
+            print_error_errno("ampliconstats", "Fail reading record");
+            goto err;
+        }
+
+        sam_hdr_destroy(header);
+        if (sam_close(fp) < 0) {
+            fp = NULL;
+            goto err;
+        }
+
+        fp = NULL;
+        header = NULL;
+
+        if (dump_lstats(args, 'F', sname, filec, amps, nref) < 0)
+            goto err;
+
+        if (append_stats(amps, nref) < 0)
+            goto err;
+
+        if (sname && sname != sname_)
+            free(sname);
+        sname = NULL;
+    }
+
+    if (dump_gstats(args, 'C', "COMBINED", filec, amps, nref) < 0)
+        goto err;
+
+    ret = 0;
+ err:
+    bam_destroy1(b);
+    if (ret) {
+        if (header)
+            sam_hdr_destroy(header);
+        if (fp)
+            sam_close(fp);
+    }
+    for (i = 0; i < nref; i++) {
+        stats_free(amps[i].lstats);
+        stats_free(amps[i].gstats);
+        free(amps[i].amp);
+    }
+    free(amps);
+    free(pos2start);
+    free(pos2end);
+    if (ret) {
+        if (sname && sname != sname_)
+            free(sname);
+    }
+
+    return ret;
+}
+
+static int usage(astats_args_t *args, FILE *fp, int exit_status) {
+    fprintf(fp,
+"\n"
+"Usage: samtools ampliconstats [options] primers.bed *.bam > astats.txt\n"
+"\n"
+"Options:\n");
+    fprintf(fp, "  -f, --required-flag STR|INT\n"
+            "               Only include reads with all of the FLAGs present [0x%X]\n",args->flag_require);
+    fprintf(fp, "  -F, --filter-flag STR|INT\n"
+            "               Only include reads with none of the FLAGs present [0x%X]\n",args->flag_filter & 0xffff);
+    fprintf(fp, "  -a, --max-amplicons INT\n"
+            "               Change the maximum number of amplicons permitted [%d]\n", MAX_AMP);
+    fprintf(fp, "  -l, --max-amplicon-length INT\n"
+            "               Change the maximum length of an individual amplicon [%d]\n", MAX_AMP_LEN);
+    fprintf(fp, "  -d, --min-depth INT[,INT]...\n"
+            "               Minimum base depth(s) to consider position covered [%d]\n", args->min_depth[0]);
+    fprintf(fp, "  -m, --pos-margin INT\n"
+            "               Margin of error for matching primer positions [%d]\n", args->max_delta);
+    fprintf(fp, "  -o, --output FILE\n"
+            "               Specify output file [samtools_stdout if unset]\n");
+    fprintf(fp, "  -s, --use-sample-name\n"
+            "               Use the sample name from the first @RG header line\n");
+    fprintf(fp, "  -t, --tlen-adjust INT\n"
+            "               Add/subtract from TLEN; use when clipping but no fixmate step\n");
+    fprintf(fp, "  -b, --tcoord-bin INT\n"
+            "               Bin template start,end positions into multiples of INT[1]\n");
+    fprintf(fp, "  -c, --tcoord-min-count INT\n"
+            "               Minimum template start,end frequency for recording [%d]\n", TCOORD_MIN_COUNT);
+    fprintf(fp, "  -D, --depth-bin FRACTION\n"
+            "               Merge FDP values within +/- FRACTION together\n");
+    fprintf(fp, "  -S, --single-ref\n"
+            "               Force single-ref (<=1.12) output format\n");
+    sam_global_opt_help(fp, "I.--.@");
+
+    return exit_status;
+}
+
+int main_ampliconstats(int argc, char **argv) {
+    astats_args_t args = {
+        .ga = SAM_GLOBAL_ARGS_INIT,
+        .flag_require = 0,
+        .flag_filter = 0x10B04,
+        //.sites = BED_LIST_INIT,
+        .max_delta = 30, // large enough to cope with alt primers
+        .min_depth = {1},
+        .use_sample_name = 0,
+        .max_amp = MAX_AMP,
+        .max_amp_len = MAX_AMP_LEN,
+        .tlen_adj = 0,
+        .out_fp = samtools_stdout,
+        .tcoord_min_count = TCOORD_MIN_COUNT,
+        .tcoord_bin = 1,
+        .depth_bin = 0.01,
+        .multi_ref = 1
+    }, oargs = args;
+
+    static const struct option loptions[] =
+    {
+        SAM_OPT_GLOBAL_OPTIONS('I', 0, '-', '-', 0, '@'),
+        {"help", no_argument, NULL, 'h'},
+        {"flag-require", required_argument, NULL, 'f'},
+        {"flag-filter", required_argument, NULL, 'F'},
+        {"min-depth", required_argument, NULL, 'd'},
+        {"output", required_argument, NULL, 'o'},
+        {"pos-margin", required_argument, NULL, 'm'},
+        {"use-sample-name", no_argument, NULL, 's'},
+        {"max-amplicons", required_argument, NULL, 'a'},
+        {"max-amplicon-length", required_argument, NULL, 'l'},
+        {"tlen-adjust", required_argument, NULL, 't'},
+        {"tcoord-min-count", required_argument, NULL, 'c'},
+        {"tcoord-bin", required_argument, NULL, 'b'},
+        {"depth-bin", required_argument, NULL, 'D'},
+        {"single-ref", no_argument, NULL, 'S'},
+        {NULL, 0, NULL, 0}
+    };
+    int opt;
+
+    while ( (opt=getopt_long(argc,argv,"?hf:F:@:p:m:d:sa:l:t:o:c:b:D:S",loptions,NULL))>0 ) {
+        switch (opt) {
+        case 'f': args.flag_require = bam_str2flag(optarg); break;
+        case 'F':
+            if (args.flag_filter & 0x10000)
+                args.flag_filter = 0; // strip default on first -F usage
+            args.flag_filter |= bam_str2flag(optarg); break;
+
+        case 'm': args.max_delta = atoi(optarg); break; // margin
+        case 'D': args.depth_bin = atof(optarg); break; // depth bin fraction
+        case 'd': {
+            int d = 0;
+            char *cp = optarg, *ep;
+            do {
+                long n = strtol(cp, &ep, 10);
+                args.min_depth[d++] = n;
+                if (*ep != ',')
+                    break;
+                cp = ep+1;
+            } while (d < MAX_DEPTH);
+            break;
+        }
+
+        case 'a': args.max_amp = atoi(optarg)+1;break;
+        case 'l': args.max_amp_len = atoi(optarg)+1;break;
+
+        case 'c': args.tcoord_min_count = atoi(optarg);break;
+        case 'b':
+            args.tcoord_bin = atoi(optarg);
+            if (args.tcoord_bin < 1)
+                args.tcoord_bin = 1;
+            break;
+
+        case 't': args.tlen_adj = atoi(optarg);break;
+
+        case 's': args.use_sample_name = 1;break;
+
+        case 'o':
+            if (!(args.out_fp = fopen(optarg, "w"))) {
+                perror(optarg);
+                return 1;
+            }
+            break;
+
+        case 'S':
+            args.multi_ref = 0;
+            break;
+
+        case '?': return usage(&oargs, samtools_stderr, EXIT_FAILURE);
+        case 'h': return usage(&oargs, samtools_stdout, EXIT_SUCCESS);
+
+        default:
+            if (parse_sam_global_opt(opt, optarg, loptions, &args.ga) != 0)
+                usage(&oargs,samtools_stderr, EXIT_FAILURE);
+            break;
+        }
+    }
+
+    if (argc <= optind)
+        return usage(&oargs, samtools_stdout, EXIT_SUCCESS);
+    if (argc <= optind+1 && isatty(STDIN_FILENO))
+        return usage(&oargs, samtools_stderr, EXIT_FAILURE);
+
+    khash_t(bed_list_hash) *bed_hash = kh_init(bed_list_hash);
+    if (load_bed_file_multi_ref(argv[optind], 1, 0, bed_hash)) {
+        print_error_errno("ampliconstats",
+                          "Could not read file \"%s\"", argv[optind]);
+        return 1;
+
+    }
+
+    khiter_t k, ref_count = 0;
+    for (k = kh_begin(bed_hash); k != kh_end(bed_hash); k++) {
+        if (!kh_exist(bed_hash, k))
+            continue;
+        ref_count++;
+    }
+    if (ref_count == 0)
+        return 1;
+    if (ref_count > 1 && args.multi_ref == 0) {
+        print_error("ampliconstats",
+                    "Single-ref mode is not permitted for BED files\n"
+                    "containing more than one reference.");
+        return 1;
+    }
+
+    args.argv = stringify_argv(argc, argv);
+    int ret;
+    if (argc == ++optind) {
+        char *av = "-";
+        ret = amplicon_stats(&args, bed_hash, &av, 1);
+    } else {
+        ret = amplicon_stats(&args, bed_hash, &argv[optind], argc-optind);
+    }
+
+    free(args.argv);
+    destroy_bed_hash(bed_hash);
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam.c

@@ -0,0 +1,267 @@
+/*  bam.c -- miscellaneous BAM functions.
+
+    Copyright (C) 2008-2013, 2015, 2019-2020, 2022 Genome Research Ltd.
+    Portions copyright (C) 2009-2012 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <errno.h>
+#include "bam.h"
+#include "htslib/kstring.h"
+
+// FIXME: we should also check the LB tag associated with each alignment
+const char *bam_get_library(sam_hdr_t *h, const bam1_t *b)
+{
+    const char *rg;
+    kstring_t lib = { 0, 0, NULL };
+    rg = (char *)bam_aux_get(b, "RG");
+
+    if (!rg)
+        return NULL;
+    else
+        rg++;
+
+    if (sam_hdr_find_tag_id(h, "RG", "ID", rg, "LB", &lib)  < 0)
+        return NULL;
+
+    static char LB_text[1024];
+    int len = lib.l < sizeof(LB_text) - 1 ? lib.l : sizeof(LB_text) - 1;
+
+    memcpy(LB_text, lib.s, len);
+    LB_text[len] = 0;
+
+    free(lib.s);
+
+    return LB_text;
+}
+
+/************
+ * Remove B *
+ ************/
+
+#define bam1_seq_seti(s, i, c) ( (s)[(i)>>1] = ((s)[(i)>>1] & 0xf<<(((i)&1)<<2)) | (c)<<((~(i)&1)<<2) )
+
+int bam_remove_B(bam1_t *b)
+{
+    int i, j, end_j, k, l, no_qual;
+    uint32_t *cigar, *new_cigar;
+    uint8_t *seq, *qual, *p;
+    // test if removal is necessary
+    if (b->core.flag & BAM_FUNMAP) return 0; // unmapped; do nothing
+    cigar = bam_get_cigar(b);
+    for (k = 0; k < b->core.n_cigar; ++k)
+        if (bam_cigar_op(cigar[k]) == BAM_CBACK) break;
+    if (k == b->core.n_cigar) return 0; // no 'B'
+    if (bam_cigar_op(cigar[0]) == BAM_CBACK) goto rmB_err; // cannot be removed
+    // allocate memory for the new CIGAR
+    if (b->l_data + (b->core.n_cigar + 1) * 4 > b->m_data) { // not enough memory
+        b->m_data = b->l_data + b->core.n_cigar * 4;
+        kroundup32(b->m_data);
+        b->data = (uint8_t*)realloc(b->data, b->m_data);
+        cigar = bam_get_cigar(b); // after realloc, cigar may be changed
+    }
+    new_cigar = (uint32_t*)(b->data + (b->m_data - b->core.n_cigar * 4)); // from the end of b->data
+    // the core loop
+    seq = bam_get_seq(b); qual = bam_get_qual(b);
+    no_qual = (qual[0] == 0xff); // test whether base quality is available
+    i = j = 0; end_j = -1;
+    for (k = l = 0; k < b->core.n_cigar; ++k) {
+        int op  = bam_cigar_op(cigar[k]);
+        int len = bam_cigar_oplen(cigar[k]);
+        if (op == BAM_CBACK) { // the backward operation
+            int t, u;
+            if (k == b->core.n_cigar - 1) break; // ignore 'B' at the end of CIGAR
+            if (len > j) goto rmB_err; // an excessively long backward
+            for (t = l - 1, u = 0; t >= 0; --t) { // look back
+                int op1  = bam_cigar_op(new_cigar[t]);
+                int len1 = bam_cigar_oplen(new_cigar[t]);
+                if (bam_cigar_type(op1)&1) { // consume the query
+                    if (u + len1 >= len) { // stop
+                        new_cigar[t] -= (len - u) << BAM_CIGAR_SHIFT;
+                        break;
+                    } else u += len1;
+                }
+            }
+            if (bam_cigar_oplen(new_cigar[t]) == 0) --t; // squeeze out the zero-length operation
+            l = t + 1;
+            end_j = j; j -= len;
+        } else { // other CIGAR operations
+            new_cigar[l++] = cigar[k];
+            if (bam_cigar_type(op)&1) { // consume the query
+                if (i != j) { // no need to copy if i == j
+                    int u, c, c0;
+                    for (u = 0; u < len; ++u) { // construct the consensus
+                        c = bam_seqi(seq, i+u);
+                        if (j + u < end_j) { // in an overlap
+                            c0 = bam_seqi(seq, j+u);
+                            if (c != c0) { // a mismatch; choose the better base
+                                if (qual[j+u] < qual[i+u]) { // the base in the 2nd segment is better
+                                    bam1_seq_seti(seq, j+u, c);
+                                    qual[j+u] = qual[i+u] - qual[j+u];
+                                } else qual[j+u] -= qual[i+u]; // the 1st is better; reduce base quality
+                            } else qual[j+u] = qual[j+u] > qual[i+u]? qual[j+u] : qual[i+u];
+                        } else { // not in an overlap; copy over
+                            bam1_seq_seti(seq, j+u, c);
+                            qual[j+u] = qual[i+u];
+                        }
+                    }
+                }
+                i += len, j += len;
+            }
+        }
+    }
+    if (no_qual) qual[0] = 0xff; // in very rare cases, this may be modified
+    // merge adjacent operations if possible
+    for (k = 1; k < l; ++k)
+        if (bam_cigar_op(new_cigar[k]) == bam_cigar_op(new_cigar[k-1]))
+            new_cigar[k] += new_cigar[k-1] >> BAM_CIGAR_SHIFT << BAM_CIGAR_SHIFT, new_cigar[k-1] &= 0xf;
+    // kill zero length operations
+    for (k = i = 0; k < l; ++k)
+        if (new_cigar[k] >> BAM_CIGAR_SHIFT)
+            new_cigar[i++] = new_cigar[k];
+    l = i;
+    // update b
+    memcpy(cigar, new_cigar, l * 4); // set CIGAR
+    p = b->data + b->core.l_qname + l * 4;
+    memmove(p, seq, (j+1)>>1); p += (j+1)>>1; // set SEQ
+    memmove(p, qual, j); p += j; // set QUAL
+    memmove(p, bam_get_aux(b), bam_get_l_aux(b)); p += bam_get_l_aux(b); // set optional fields
+    b->core.n_cigar = l, b->core.l_qseq = j; // update CIGAR length and query length
+    b->l_data = p - b->data; // update record length
+    return 0;
+
+rmB_err:
+    b->core.flag |= BAM_FUNMAP;
+    return -1;
+}
+
+/* Calculate the current read's start based on the stored cigar string. */
+hts_pos_t unclipped_start(bam1_t *b) {
+    uint32_t *cigar = bam_get_cigar(b);
+    int64_t clipped = 0;
+    uint32_t i;
+
+    for (i = 0; i < b->core.n_cigar; i++) {
+        char c = bam_cigar_opchr(cigar[i]);
+
+        if (c == 'S' || c == 'H') { // clips
+            clipped += bam_cigar_oplen(cigar[i]);
+        } else {
+            break;
+        }
+    }
+
+    return b->core.pos - clipped + 1;
+}
+
+/* Calculate the mate's unclipped start based on position and cigar string from MC tag. */
+hts_pos_t unclipped_other_start(hts_pos_t op, char *cigar) {
+    char *c = cigar;
+    int64_t clipped = 0;
+
+    while (*c && *c != '*') {
+        long num = 0;
+
+        if (isdigit((int)*c)) {
+            num = strtol(c, &c, 10);
+        } else {
+            num = 1;
+        }
+
+        if (*c == 'S' || *c == 'H') { // clips
+            clipped += num;
+        } else {
+            break;
+        }
+
+        c++;
+    }
+
+    return op - clipped + 1;
+}
+
+/* Calculate the current read's end based on the stored cigar string. */
+hts_pos_t unclipped_end(bam1_t *b) {
+    uint32_t *cigar = bam_get_cigar(b);
+    hts_pos_t end_pos, clipped = 0;
+    int32_t i;
+
+    end_pos = bam_endpos(b);
+
+    // now get the clipped end bases (if any)
+    // if we get to the beginning of the cigar string
+    // without hitting a non-clip then the results are meaningless
+    for (i = b->core.n_cigar - 1; i >= 0; i--) {
+        char c = bam_cigar_opchr(cigar[i]);
+
+        if (c == 'S' || c == 'H') { // clips
+            clipped += bam_cigar_oplen(cigar[i]);
+        } else {
+            break;
+        }
+    }
+
+    return end_pos + clipped;
+}
+
+
+/* Calculate the mate's unclipped end based on start position and cigar string from MC tag.*/
+hts_pos_t unclipped_other_end(int64_t op, char *cigar) {
+    char *c = cigar;
+    int64_t refpos = 0;
+    int skip = 1;
+
+    while (*c && *c != '*') {
+        long num = 0;
+
+        if (isdigit((int)*c)) {
+            num = strtol(c, &c, 10);
+        } else {
+            num = 1;
+        }
+
+        switch (*c) {
+            case 'M':
+            case 'D':
+            case 'N':
+            case '=':
+            case 'X':
+                refpos += num;
+                skip = 0; // ignore initial clips
+            break;
+
+            case 'S':
+            case 'H':
+                if (!skip) {
+                refpos += num;
+            }
+            break;
+        }
+
+        c++;
+   }
+
+    return  op + refpos;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam.h

@@ -0,0 +1,39 @@
+/*  bam.h -- miscellaneous BAM functions.
+
+    Copyright (C) 2008-2014, 2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#ifndef BAM_BAM_H
+#define BAM_BAM_H
+
+#include "htslib/sam.h"
+
+int bam_remove_B(bam1_t *b);
+
+const char *bam_get_library(sam_hdr_t *header, const bam1_t *b);
+
+hts_pos_t unclipped_start(bam1_t *b);
+hts_pos_t unclipped_other_start(hts_pos_t op, char *cigar);
+hts_pos_t unclipped_end(bam1_t *b);
+hts_pos_t unclipped_other_end(int64_t op, char *cigar);
+
+#endif

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam2depth.c

@@ -0,0 +1,999 @@
+/*  bam2depth.c -- depth subcommand.
+
+    Copyright (C) 2011, 2012 Broad Institute.
+    Copyright (C) 2012-2016, 2018, 2019-2022 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk> (to 2020)
+    Author: James Bonfield <jkb@sanger.ac.uk> (2021 rewrite)
+
+
+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.  */
+
+/* This program demonstrates how to generate pileup from multiple BAMs
+ * simultaneously, to achieve random access and to use the BED interface.
+ * To compile this program separately, you may:
+ *
+ *   gcc -g -O2 -Wall -o bam2depth -D_MAIN_BAM2DEPTH bam2depth.c -lhts -lz
+ */
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <unistd.h>
+#include "htslib/sam.h"
+#include "samtools.h"
+#include "bedidx.h"
+#include "sam_opts.h"
+#include "htslib/khash.h"
+
+// From bam_plcmd.c
+int read_file_list(const char *file_list, int *n, char **argv[]);
+
+// We accumulate to hist[pos & (size-1)].  This is a ring-buffer.
+// We track where we last got to in output and what the biggest value
+// we've written to so far (in absolute unmasked coordinates) in
+// "last_output" and "end_pos" respectively.
+// For each new record we just flush anything we haven't written yet
+// already, between "last_output" and this read's start position, and
+// initialise any newly seen positions between "end_pos" and this read's
+// end position.
+typedef struct {
+    size_t size;
+    int **hist;         // hist[nfiles][size]
+    hts_pos_t *end_pos; // end_pos[nfiles]
+    hts_pos_t last_output;
+    int last_ref;
+    int nfiles;
+    const char *ref;
+    kstring_t ks;
+    hts_pos_t beg, end; // limit to region
+    int tid;
+} depth_hist;
+
+typedef struct {
+    int header;
+    int flag;
+    int incl_flag;
+    int require_flag;
+    int min_qual;
+    int min_mqual;
+    int min_len;
+    int skip_del;
+    int all_pos;
+    int remove_overlaps;
+    FILE *out;
+    char *reg;
+    void *bed;
+} depth_opt;
+
+static void zero_region(depth_opt *opt, depth_hist *dh,
+                        const char *name, hts_pos_t start, hts_pos_t end) {
+    hts_pos_t i;
+    kstring_t *ks = &dh->ks;
+
+    kputs(name, ks_clear(ks));
+    kputc('\t', ks);
+    size_t cur_l = ks->l;
+    if (dh->beg >= 0 && start < dh->beg)
+        start = dh->beg;
+    if (dh->end >= 0 && end > dh->end)
+        end = dh->end;
+
+    for (i = start; i < end; i++) {
+        // Could be optimised, but needs better API to skip to next
+        // bed region.
+        if (opt->bed && bed_overlap(opt->bed, name, i, i+1) == 0)
+            continue;
+
+        ks->l = cur_l;
+        kputll(i+1,  ks);
+        int n;
+        for (n = 0; n < dh->nfiles; n++) {
+            kputc_('\t', ks);
+            kputc_('0',  ks);
+        }
+        kputc('\n',  ks);
+        fputs(ks->s, opt->out);
+    }
+    ks->l = cur_l;
+}
+
+// A variation of bam_cigar2qlen which doesn't count soft-clips in to the
+// equation.  Basically it's the number of bases in query that are aligned
+// in some way to the reference (including insertions, which are considered
+// to be aligned by dint of being anchored either side).
+hts_pos_t qlen_used(bam1_t *b) {
+    int n_cigar = b->core.n_cigar;
+    const uint32_t *cigar = bam_get_cigar(b);
+
+    hts_pos_t l;
+
+    if (b->core.l_qseq) {
+        // Known SEQ permits of short cut of l_qseq minus CSOFT_CLIPs.
+        // Full scan not needed, which helps on excessively long CIGARs.
+        l = b->core.l_qseq;
+        int kl, kr;
+        for (kl = 0; kl < n_cigar; kl++)
+            if (bam_cigar_op(cigar[kl]) == BAM_CSOFT_CLIP)
+                l -= bam_cigar_oplen(cigar[kl]);
+            else
+                break;
+
+        for (kr = n_cigar-1; kr > kl; kr--)
+            if (bam_cigar_op(cigar[kr]) == BAM_CSOFT_CLIP)
+                l -= bam_cigar_oplen(cigar[kr]);
+            else
+                break;
+    } else {
+        // Unknown SEQ ("*") needs a full scan through the CIGAR string.
+        static int query[16] = {
+          //M I D N  S H P =  X B ? ?  ? ? ? ?
+            1,1,0,0, 0,0,0,1, 1,0,0,0, 0,0,0,0
+        };
+        int k;
+        for (k = l = 0; k < n_cigar; k++)
+            if (query[bam_cigar_op(cigar[k])])
+                l += bam_cigar_oplen(cigar[k]);
+    }
+    return l;
+
+}
+
+// Adds the depth for a single read to a depth_hist struct.
+// For just one file, this is easy.  We just have a circular buffer
+// where we increment values for bits that overlap existing data
+// and initialise values for coordinates which we're seeing for the first
+// time.  This is tracked by "end_pos" to know where we've got to.
+//
+// As the input is sorted, we can flush output from "last_output" to
+// b->core.pos.
+//
+// With multiple files, we must feed data in sorted order as if all files
+// are merged, but track depth per file.  This also means "end_pos" is per
+// file too, but "last_output" is global as it corresponds to rows printed.
+static int add_depth(depth_opt *opt, depth_hist *dh, sam_hdr_t *h, bam1_t *b,
+                     int overlap_clip, int file) {
+    hts_pos_t i;
+    size_t hmask = dh->size-1;
+    int n;
+
+    if (!b || b->core.tid != dh->last_ref) {
+        // New ref
+        if (dh->last_ref >= 0) {
+            // do end
+            size_t cur_l = dh->ks.l;
+            int nf = dh->nfiles;
+            i = dh->last_output;
+            for (i = dh->last_output; nf; i++) {
+                nf = 0;
+                for (n = 0; n < dh->nfiles; n++) {
+                    if (i < dh->end_pos[n])
+                        nf++;
+                }
+                if (!nf)
+                    break;
+
+                if (opt->bed && bed_overlap(opt->bed, dh->ref, i, i+1) == 0)
+                    continue;
+
+                dh->ks.l = cur_l;
+                kputll(i+1, &dh->ks);
+                for (n = 0; n < dh->nfiles; n++) {
+                    kputc_('\t', &dh->ks);
+                    int d = i < dh->end_pos[n]
+                        ? dh->hist[n][i & hmask]
+                        : 0;
+                    kputuw(d, &dh->ks);
+                }
+                kputc('\n', &dh->ks);
+                fputs(dh->ks.s, opt->out);
+            }
+            if (opt->all_pos) {
+                // End of last ref
+                zero_region(opt, dh,
+                            sam_hdr_tid2name(h, dh->last_ref),
+                            i, sam_hdr_tid2len(h, dh->last_ref));
+            }
+            dh->ks.l = cur_l;
+        }
+
+        if (opt->all_pos > 1 && !opt->reg) {
+            // Any previous unused refs
+            int lr = dh->last_ref < 0 ? 0 : dh->last_ref+1;
+            int rr = b ? b->core.tid : sam_hdr_nref(h), r;
+            for (r = lr; r < rr; r++)
+                zero_region(opt, dh,
+                            sam_hdr_tid2name(h, r),
+                            0, sam_hdr_tid2len(h, r));
+        }
+
+        if (!b) {
+            // we're just flushing to end of file
+            if (opt->all_pos && opt->reg && dh->last_ref < 0)
+                // -a or -aa without a single read being output yet
+                zero_region(opt, dh, sam_hdr_tid2name(h, dh->tid), dh->beg,
+                            MIN(dh->end, sam_hdr_tid2len(h, dh->tid)));
+
+            return 0;
+        }
+
+        for (n = 0; dh->end_pos && n < dh->nfiles; n++)
+            dh->end_pos[n] = 0;
+        dh->last_output = dh->beg >= 0
+            ? MAX(b->core.pos, dh->beg)
+            : b->core.pos;
+        dh->last_ref = b->core.tid;
+        dh->ref = sam_hdr_tid2name(h, b->core.tid);
+        kputs(dh->ref, ks_clear(&dh->ks));
+        kputc('\t', &dh->ks);
+
+        if (opt->all_pos)
+            // Start of ref
+            zero_region(opt, dh, dh->ref, 0, b->core.pos);
+    } else {
+        if (dh->last_output < b->core.pos) {
+            // Flush any depth outputs up to start of new read
+            size_t cur_l = dh->ks.l;
+            int nf = dh->nfiles;
+            for (i = dh->last_output; i < b->core.pos; i++) {
+                nf = 0;
+                for (n = 0; n < dh->nfiles; n++) {
+                    if (i < dh->end_pos[n])
+                        nf++;
+                }
+                if (!nf)
+                    break;
+
+                if (opt->bed && bed_overlap(opt->bed, dh->ref, i, i+1) == 0)
+                    continue;
+
+                dh->ks.l = cur_l;
+                kputll(i+1, &dh->ks);
+                for (n = 0; n < dh->nfiles; n++) {
+                    kputc_('\t', &dh->ks);
+                    int d = i < dh->end_pos[n]
+                        ? dh->hist[n][i & hmask]
+                        : 0;
+                    kputuw(d, &dh->ks);
+                }
+                kputc('\n', &dh->ks);
+                fputs(dh->ks.s, opt->out);
+            }
+            if (opt->all_pos && i < b->core.pos)
+                // Hole in middle of ref
+                zero_region(opt, dh, dh->ref, i, b->core.pos);
+
+            dh->ks.l = cur_l;
+            dh->last_output = b->core.pos;
+        }
+    }
+
+    hts_pos_t end_pos = bam_endpos(b); // 0 based, 1 past end.
+    //printf("%d %d\n", (int)b->core.pos+1, (int)end_pos);
+
+    if (b->core.tid < dh->last_ref ||
+        (dh->last_ref == b->core.tid && end_pos < dh->last_output)) {
+        print_error_errno("depth", "Data is not position sorted");
+        return -1;
+    }
+
+    // If needed, grow the circular buffer.
+    if (end_pos+1 - b->core.pos >= dh->size) {
+        size_t old_size = dh->size;
+        size_t old_hmask = hmask;
+        while (end_pos+1 - b->core.pos >= dh->size)
+            dh->size = dh->size ? 2*dh->size : 2048;
+        hmask = dh->size-1;
+        if (!dh->hist) {
+            dh->hist = calloc(dh->nfiles, sizeof(*dh->hist));
+            dh->end_pos = calloc(dh->nfiles, sizeof(*dh->end_pos));
+            if (!dh->hist || !dh->end_pos)
+                return -1;
+        }
+        for (n = 0; n < dh->nfiles; n++) {
+            int *hist = calloc(dh->size, sizeof(*dh->hist[n]));
+            if (!hist)
+                return -1;
+
+            // Simple approach for now; copy over old histogram verbatim.
+            for (i = dh->last_output; i < dh->last_output + old_size; i++)
+                hist[i & hmask] = dh->hist[n][i & old_hmask];
+            free(dh->hist[n]);
+            dh->hist[n] = hist;
+        }
+    }
+
+    // Accumulate depth, based on CIGAR
+    uint32_t *cig = bam_get_cigar(b);
+    int ncig = b->core.n_cigar, j, k, spos = 0;
+
+    // Zero new (previously unseen) coordinates so increment works later.
+    hts_pos_t end = MAX(dh->end_pos[file], b->core.pos);
+    if (end_pos > end && (end & hmask) < (end_pos & hmask)) {
+        memset(&dh->hist[file][end & hmask], 0,
+               sizeof(**dh->hist) * (end_pos - end));
+    } else {
+        for (i = end; i < end_pos; i++)
+            dh->hist[file][i & hmask] = 0;
+    }
+
+    i = b->core.pos;
+    uint8_t *qual = bam_get_qual(b);
+    int min_qual = opt->min_qual;
+    for (j = 0; j < ncig; j++) {
+        int op    = bam_cigar_op(cig[j]);
+        int oplen = bam_cigar_oplen(cig[j]);
+
+        switch (op) {
+        case BAM_CDEL:
+        case BAM_CREF_SKIP:
+            if (op != BAM_CDEL || opt->skip_del) {
+                // don't increment reference location
+                if (i + oplen >= dh->end_pos[file]) {
+                    for (k = 0; k < oplen; k++, i++) {
+                        if (i >= dh->end_pos[file])
+                            // redundant due to zero new elements above?
+                            dh->hist[file][i & hmask] = 0;
+                    }
+                } else {
+                    i += oplen;
+                }
+            } else { // op == BAM_CDEL and we count them (-J option),
+                // We don't incr spos here, but we still use qual.
+                // This doesn't make much sense, but it's for compatibility
+                // with the old code.  Arguably DEL shouldn't have a min
+                // qual and should always pass (as we've explicitly asked to
+                // include them).
+                int *hist = dh->hist[file];
+                k = 0;
+                if (overlap_clip) {
+                    if (i+oplen < overlap_clip) {
+                        i += oplen;
+                        break;
+                    } else if (i < overlap_clip) {
+                        k = overlap_clip - i;
+                        i = overlap_clip;
+                    }
+                }
+
+                // Question: should we even check quality values for DEL?
+                // We've explicitly asked to include them, and the quality
+                // is wrong anyway (it's the neighbouring base).  We do this
+                // for now for compatibility with the old depth command.
+
+                if (spos < b->core.l_qseq)
+                    for (; k < oplen; k++, i++)
+                        hist[i & hmask]+=qual[spos]>=min_qual;
+                else
+                    for (; k < oplen; k++, i++)
+                        hist[i & hmask]++;
+            }
+            break;
+
+        case BAM_CMATCH:
+        case BAM_CEQUAL:
+        case BAM_CDIFF:
+            if ((i & hmask) < ((i+oplen) & hmask)) {
+                // Optimisation when not wrapping around
+
+                // Unrolling doesn't help clang, but helps gcc,
+                // especially when not using -O3.
+                int *hist = &dh->hist[file][i & hmask];
+                if (min_qual || overlap_clip) {
+                    k = 0;
+                    if (overlap_clip) {
+                        if (i+oplen < overlap_clip) {
+                            i += oplen;
+                            spos += oplen;
+                            break;
+                        } else if (i < overlap_clip) {
+                            oplen -= overlap_clip - i;
+                            spos += overlap_clip - i;
+                            hist += overlap_clip - i;
+                            i = overlap_clip;
+                        }
+                    }
+
+                    // approx 50% of this func cpu time in this loop
+                    for (; k < (oplen & ~7); k+=8) {
+                        hist[k+0]+=qual[spos+0]>=min_qual;
+                        hist[k+1]+=qual[spos+1]>=min_qual;
+                        hist[k+2]+=qual[spos+2]>=min_qual;
+                        hist[k+3]+=qual[spos+3]>=min_qual;
+                        hist[k+4]+=qual[spos+4]>=min_qual;
+                        hist[k+5]+=qual[spos+5]>=min_qual;
+                        hist[k+6]+=qual[spos+6]>=min_qual;
+                        hist[k+7]+=qual[spos+7]>=min_qual;
+                        spos += 8;
+                    }
+                } else {
+                    // easier to vectorize when no min_qual
+                    for (k = 0; k < (oplen & ~7); k+=8) {
+                        hist[k+0]++;
+                        hist[k+1]++;
+                        hist[k+2]++;
+                        hist[k+3]++;
+                        hist[k+4]++;
+                        hist[k+5]++;
+                        hist[k+6]++;
+                        hist[k+7]++;
+                    }
+                    spos += k;
+                }
+                for (; k < oplen && spos < b->core.l_qseq; k++, spos++)
+                    hist[k]+=qual[spos]>=min_qual;
+                for (; k < oplen; k++, spos++)
+                    hist[k]++;
+                i += oplen;
+            } else {
+                // Simple to understand case, but slower.
+                // We use this only for reads with wrap-around.
+                int *hist = dh->hist[file];
+                k = 0;
+                if (overlap_clip) {
+                    if (i+oplen < overlap_clip) {
+                        i += oplen;
+                        break;
+                    } else if (i < overlap_clip) {
+                        oplen -= overlap_clip - i;
+                        spos += overlap_clip - i;
+                        i = overlap_clip;
+                    }
+                }
+                for (; k < oplen && spos < b->core.l_qseq; k++, i++, spos++)
+                    hist[i & hmask]+=qual[spos]>=min_qual;
+                for (; k < oplen; k++, i++, spos++)
+                    hist[i & hmask]++;
+            }
+            break;
+
+        case BAM_CINS:
+        case BAM_CSOFT_CLIP:
+            spos += oplen;
+            break;
+
+        case BAM_CPAD:
+        case BAM_CHARD_CLIP:
+            // ignore
+            break;
+
+        default:
+            print_error("depth", "Unsupported cigar op '%d'", op);
+            return -1;
+        }
+    }
+
+    if (dh->end >= 0 && end_pos > dh->end)
+        end_pos = dh->end;
+    if (dh->end_pos[file] < end_pos)
+        dh->end_pos[file] = end_pos;
+
+    return 0;
+}
+
+// Hash on name -> alignment end pos. This permits a naive overlap removal.
+// Note it cannot analyse the overlapping sequence and qualities, so the
+// interaction of basecalls/qualities and the -Q parameter cannot be
+// applied here (unlike the full mpileup algorithm).
+KHASH_MAP_INIT_STR(olap_hash, hts_pos_t)
+typedef khash_t(olap_hash) olap_hash_t;
+
+static int fastdepth_core(depth_opt *opt, uint32_t nfiles, char **fn,
+                          samFile **fp, hts_itr_t **itr, sam_hdr_t **h) {
+    int ret = -1, err = 1, i;
+    olap_hash_t **overlaps = NULL;
+    depth_hist dh = {0};
+
+    // An array of bam structs, one per input file, to hold the next entry
+    bam1_t **b = calloc(nfiles, sizeof(*b));
+    int *finished = calloc(nfiles, sizeof(*finished)), to_go = nfiles;
+    if (!b || !finished)
+        goto err;
+
+    for (i = 0; i < nfiles; i++)
+        if (!(b[i] = bam_init1()))
+            goto err;
+
+    // Do we need one overlap hash per file? Or shared?
+    if (opt->remove_overlaps) {
+        if (!(overlaps = calloc(nfiles, sizeof(*overlaps))))
+            return -1;
+        for (i = 0; i < nfiles; i++) {
+            if (!(overlaps[i] = kh_init(olap_hash)))
+                return -1;
+        }
+    }
+
+    // Create the initial histogram
+    dh.nfiles = nfiles;
+    dh.size = 0;
+    dh.hist = NULL;
+    dh.last_ref = -99;
+    dh.end_pos = NULL;
+    dh.last_output = itr && itr[0] ? itr[0]->beg : 0;
+    ks_initialize(&dh.ks);
+
+    // Clip results to region if specified
+    dh.beg = -1;
+    dh.end = -1;
+    dh.tid = 0;
+    if (itr && itr[0]) {
+        dh.tid = itr[0]->tid;
+        dh.beg = itr[0]->beg;
+        dh.end = itr[0]->end;
+    }
+
+    if (opt->header) {
+        fprintf(opt->out, "#CHROM\tPOS");
+        for (i = 0; i < nfiles; i++)
+            fprintf(opt->out, "\t%s", fn[i]);
+        fputc('\n', opt->out);
+    }
+
+    // Populate first record per file
+    for (i = 0; i < nfiles; i++) {
+        for(;;) {
+            ret = itr && itr[i]
+                ? sam_itr_next(fp[i], itr[i], b[i])
+                : sam_read1(fp[i], h[i], b[i]);
+            if (ret < -1)
+                goto err;
+            if (ret == -1) {
+                to_go--;
+                finished[i] = 1;
+                break;
+            }
+
+            if (b[i]->core.tid < 0)
+                continue;
+            if (b[i]->core.flag & opt->flag)
+                continue; // must have none of the flags set
+            if (opt->incl_flag && (b[i]->core.flag & opt->incl_flag) == 0)
+                continue; // must have at least one flag set
+            if ((b[i]->core.flag & opt->require_flag) != opt->require_flag)
+                continue; // must have all lags set
+            if (b[i]->core.qual < opt->min_mqual)
+                continue;
+
+            // Original samtools depth used the total sequence (l_qseq)
+            // including soft-clips.  This doesn't feel like a useful metric
+            // to be filtering on.  We now only count sequence bases that
+            // form the used part of the alignment.
+            if (opt->min_len) {
+                if (qlen_used(b[i]) < opt->min_len)
+                    continue;
+            }
+
+            break;
+        }
+    }
+
+    // Loop through input files, merging in order so we're
+    // always adding the next record in sequence
+    while (to_go) {
+        // Find next record in file list
+        int best_tid = INT_MAX, best_file = 0;
+        hts_pos_t best_pos = HTS_POS_MAX;
+
+        for (i = 0; i < nfiles; i++) {
+            if (finished[i])
+                continue;
+            if (best_tid > b[i]->core.tid) {
+                best_tid = b[i]->core.tid;
+                best_pos = b[i]->core.pos;
+                best_file = i;
+            } else if (best_tid == b[i]->core.tid &&
+                       best_pos > b[i]->core.pos) {
+                best_pos = b[i]->core.pos;
+                best_file = i;
+            }
+        }
+        i = best_file;
+
+        hts_pos_t clip = 0;
+        if (overlaps && (b[i]->core.flag & BAM_FPAIRED) &&
+            !(b[i]->core.flag & BAM_FMUNMAP)) {
+            khiter_t k = kh_get(olap_hash, overlaps[i], bam_get_qname(b[i]));
+            if (k == kh_end(overlaps[i])) {
+                // not seen before
+                hts_pos_t endpos = bam_endpos(b[i]);
+
+                // Don't add if mate location is known and can't overlap.
+                if (b[i]->core.mpos == -1 ||
+                    (b[i]->core.tid == b[i]->core.mtid &&
+                     b[i]->core.mpos <= endpos)) {
+                    k = kh_put(olap_hash, overlaps[i], bam_get_qname(b[i]),
+                               &ret);
+                    if (ret < 0)
+                        return -1;
+                    kh_key(overlaps[i], k) = strdup(bam_get_qname(b[i]));
+                    kh_value(overlaps[i], k) = endpos;
+                }
+            } else {
+                // seen before
+                clip = kh_value(overlaps[i], k);
+                free((char *)kh_key(overlaps[i], k));
+                kh_del(olap_hash, overlaps[i], k);
+            }
+        }
+
+        // Add the next merged BAM record to the depth plot
+        if ((ret = add_depth(opt, &dh, h[i], b[i], clip, i)) < 0) {
+            ret = -1;
+            goto err;
+        }
+
+        // Populate next record from this file
+        for(;!finished[i];) {
+            ret = itr && itr[i]
+                ? sam_itr_next(fp[i], itr[i], b[i])
+                : sam_read1(fp[i], h[i], b[i]);
+            if (ret < -1) {
+                ret = -1;
+                goto err;
+            }
+            if (ret == -1) {
+                to_go--;
+                finished[i] = 1;
+                break;
+            }
+
+            if (b[i]->core.tid < 0)
+                continue;
+            if (b[i]->core.flag & opt->flag)
+                continue; // must have none of the flags set
+            if (opt->incl_flag && (b[i]->core.flag & opt->incl_flag) == 0)
+                continue; // must have at least one flag set
+            if ((b[i]->core.flag & opt->require_flag) != opt->require_flag)
+                continue; // must have all lags set
+            if (b[i]->core.qual < opt->min_mqual)
+                continue;
+
+            if (opt->min_len) {
+                if (qlen_used(b[i]) < opt->min_len)
+                    continue;
+            }
+
+            break;
+        }
+    }
+
+    // Tidy up end.
+    ret = add_depth(opt, &dh, h[0], NULL, 0, 0);
+    err = 0;
+
+ err:
+    if (ret == 0 && err)
+        ret = -1;
+
+    for (i = 0; i < nfiles; i++) {
+        if (b[i])
+            bam_destroy1(b[i]);
+        if (dh.hist && dh.hist[i])
+            free(dh.hist[i]);
+    }
+    free(b);
+    free(finished);
+    ks_free(&dh.ks);
+    free(dh.hist);
+    free(dh.end_pos);
+    if (overlaps) {
+        khiter_t k;
+        for (i = 0; i < nfiles; i++) {
+            if (!overlaps[i])
+                continue;
+            for (k = kh_begin(overlaps[i]); k < kh_end(overlaps[i]); k++)
+                if (kh_exist(overlaps[i], k))
+                    free((char *)kh_key(overlaps[i], k));
+            kh_destroy(olap_hash, overlaps[i]);
+        }
+        free(overlaps);
+    }
+
+    return ret;
+}
+
+static void usage_exit(FILE *fp, int exit_status)
+{
+    fprintf(fp, "Usage: samtools depth [options] in.bam [in.bam ...]\n");
+    fprintf(fp, "\nOptions:\n");
+    fprintf(fp, "  -a           Output all positions (including zero depth)\n");
+    fprintf(fp, "  -a -a, -aa   Output absolutely all positions, including unused ref seqs\n");
+    fprintf(fp, "  -r REG       Specify a region in chr or chr:from-to syntax\n");
+    fprintf(fp, "  -b FILE      Use bed FILE for list of regions\n");
+    fprintf(fp, "  -f FILE      Specify list of input BAM/SAM/CRAM filenames\n");
+    fprintf(fp, "  -X           Use custom index files (in -X *.bam *.bam.bai order)\n");
+    fprintf(fp, "  -g INT       Remove specified flags from default filter-out flag list\n");
+    fprintf(fp, "  -G, --excl-flags FLAGS\n");
+    fprintf(fp, "               Add specified flags to the  default filter-out flag list\n");
+    fprintf(fp, "               [UNMAP,SECONDARY,QCFAIL,DUP]\n");
+    fprintf(fp, "      --incl-flags FLAGS\n");
+    fprintf(fp, "               Only include records with at least one the FLAGs present [0]\n");
+    fprintf(fp, "      --require-flags FLAGS\n");
+    fprintf(fp, "               Only include records with all of the FLAGs present [0]\n");
+    fprintf(fp, "  -H           Print a file header line\n");
+    fprintf(fp, "  -l INT       Minimum read length [0]\n");
+    fprintf(fp, "  -o FILE      Write output to FILE [stdout]\n");
+    fprintf(fp, "  -q, --min-BQ INT\n"
+                "               Filter bases with base quality smaller than INT [0]\n");
+    fprintf(fp, "  -Q, --min-MQ INT\n"
+                "               Filter alignments with mapping quality smaller than INT [0]\n");
+    fprintf(fp, "  -J           Include reads with deletions in depth computation\n");
+    fprintf(fp, "  -s           Do not count overlapping reads within a template\n");
+    sam_global_opt_help(fp, "-.--.@-.");
+    exit(exit_status);
+}
+
+int main_depth(int argc, char *argv[])
+{
+    int nfiles, i;
+    samFile **fp;
+    sam_hdr_t **header;
+    int c, has_index_file = 0;
+    char *file_list = NULL, **fn = NULL;
+    char *out_file = NULL;
+    depth_opt opt = {
+        .flag = BAM_FUNMAP | BAM_FSECONDARY | BAM_FDUP | BAM_FQCFAIL,
+        .incl_flag = 0,
+        .require_flag = 0,
+        .min_qual = 0,
+        .min_mqual = 0,
+        .skip_del = 1,
+        .header = 0,
+        .min_len = 0,
+        .out = stdout,
+        .all_pos = 0,
+        .remove_overlaps = 0,
+        .reg = NULL,
+        .bed = NULL,
+    };
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        {"min-MQ",        required_argument, NULL, 'Q'},
+        {"min-mq",        required_argument, NULL, 'Q'},
+        {"min-BQ",        required_argument, NULL, 'q'},
+        {"min-bq",        required_argument, NULL, 'q'},
+        {"excl-flags",    required_argument, NULL, 'G'},
+        {"incl-flags",    required_argument, NULL, 1},
+        {"require-flags", required_argument, NULL, 2},
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', 0, '@'),
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "@:q:Q:JHd:m:l:g:G:o:ar:Xf:b:s",
+                            lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'a':
+            opt.all_pos++;
+            break;
+
+        case 'b':
+            opt.bed = bed_read(optarg);
+            if (!opt.bed) {
+                print_error_errno("depth", "Could not read file \"%s\"",
+                                  optarg);
+                return 1;
+            }
+            break;
+
+        case 'f':
+            file_list = optarg;
+            break;
+
+        case 'd':
+        case 'm':
+            // depth limit - now ignored
+            break;
+
+        case 'g':
+            opt.flag &= ~bam_str2flag(optarg);
+            break;
+        case 'G': // reject if any set
+            opt.flag |= bam_str2flag(optarg);
+            break;
+        case 1: // reject unless at least one set (0 means ignore option)
+            opt.incl_flag |= bam_str2flag(optarg);
+            break;
+        case 2: // reject unless all set
+            opt.require_flag |= bam_str2flag(optarg);
+            break;
+
+        case 'l':
+            opt.min_len = atoi(optarg);
+            break;
+
+        case 'H':
+            opt.header = 1;
+            break;
+
+        case 'q':
+            opt.min_qual = atoi(optarg);
+            break;
+        case 'Q':
+            opt.min_mqual = atoi(optarg);
+            break;
+
+        case 'J':
+            opt.skip_del = 0;
+            break;
+
+        case 'o':
+            if (opt.out != stdout)
+                break;
+            opt.out = fopen(out_file = optarg, "w");
+            if (!opt.out) {
+                print_error_errno("depth", "Cannot open \"%s\" for writing.",
+                                  optarg);
+                return EXIT_FAILURE;
+            }
+            break;
+
+        case 'r':
+            opt.reg = optarg;
+            break;
+
+        case 's':
+            opt.remove_overlaps = 1;
+            break;
+
+        case 'X':
+            has_index_file = 1;
+            break;
+
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage_exit(stderr, EXIT_FAILURE);
+        }
+    }
+
+    if (argc < optind+1 && !file_list) {
+        if (argc == optind)
+            usage_exit(stdout, EXIT_SUCCESS);
+        else
+            usage_exit(stderr, EXIT_FAILURE);
+    }
+
+    if (file_list) {
+        if (has_index_file) {
+            print_error("depth", "The -f option cannot be combined with -X");
+            return 1;
+        }
+        if (read_file_list(file_list, &nfiles, &fn))
+            return 1;
+        argv = fn;
+        argc = nfiles;
+        optind = 0;
+    } else {
+        nfiles = argc - optind;
+    }
+
+    if (has_index_file) {
+        if (nfiles%1) {
+            print_error("depth", "-X needs one index specified per bam file");
+            return 1;
+        }
+        nfiles /= 2;
+    }
+    fp = malloc(nfiles * sizeof(*fp));
+    header = malloc(nfiles * sizeof(*header));
+    if (!fp || !header) {
+        print_error_errno("depth", "Out of memory");
+        return 1;
+    }
+
+    hts_itr_t **itr = NULL;
+    if (opt.reg) {
+        itr = calloc(nfiles, sizeof(*itr));
+        if (!itr)
+            return 1;
+    }
+
+    for (i = 0; i < nfiles; i++, optind++) {
+        fp[i] = sam_open_format(argv[optind], "r", &ga.in);
+        if (fp[i] == NULL) {
+            print_error_errno("depth",
+                              "Cannot open input file \"%s\"", argv[optind]);
+            return 1;
+        }
+
+        if (ga.nthreads > 0)
+            hts_set_threads(fp[i], ga.nthreads);
+
+        if (hts_set_opt(fp[i], CRAM_OPT_REQUIRED_FIELDS,
+                        SAM_FLAG | SAM_RNAME | SAM_POS | SAM_CIGAR
+                        | (opt.remove_overlaps ? SAM_QNAME|SAM_RNEXT|SAM_PNEXT
+                                               : 0)
+                        | (opt.min_mqual       ? SAM_MAPQ  : 0)
+                        | (opt.min_len         ? SAM_SEQ   : 0)
+                        | (opt.min_qual        ? SAM_QUAL  : 0))) {
+            fprintf(stderr, "Failed to set CRAM_OPT_REQUIRED_FIELDS value\n");
+            return 1;
+        }
+
+        if (hts_set_opt(fp[i], CRAM_OPT_DECODE_MD, 0)) {
+            fprintf(stderr, "Failed to set CRAM_OPT_DECODE_MD value\n");
+            return 1;
+        }
+
+        // FIXME: what if headers differ?
+        header[i] = sam_hdr_read(fp[i]);
+        if (header == NULL) {
+            fprintf(stderr, "Failed to read header for \"%s\"\n",
+                    argv[optind]);
+            return 1;
+        }
+
+        if (opt.reg) {
+            hts_idx_t *idx = has_index_file
+                ? sam_index_load2(fp[i], argv[optind], argv[optind+nfiles])
+                : sam_index_load(fp[i], argv[optind]);
+            if (!idx) {
+                print_error("depth", "cannot load index for \"%s\"",
+                            argv[optind]);
+                return 1;
+            }
+            if (!(itr[i] = sam_itr_querys(idx, header[i], opt.reg))) {
+                print_error("depth", "cannot parse region \"%s\"", opt.reg);
+                return 1;
+            }
+            hts_idx_destroy(idx);
+        }
+    }
+
+    int ret = fastdepth_core(&opt, nfiles, &argv[argc-nfiles], fp, itr, header)
+        ? 1 : 0;
+
+    for (i = 0; i < nfiles; i++) {
+        sam_hdr_destroy(header[i]);
+        sam_close(fp[i]);
+        if (itr && itr[i])
+            hts_itr_destroy(itr[i]);
+    }
+    free(header);
+    free(fp);
+    free(itr);
+    if (file_list) {
+        for (i=0; i<nfiles; i++)
+            free(fn[i]);
+        free(fn);
+    }
+    if (opt.bed)
+        bed_destroy(opt.bed);
+    sam_global_args_free(&ga);
+    if (opt.out != stdout) {
+        if (fclose(opt.out) != 0 && ret == 0) {
+            print_error_errno("depth", "error on closing \"%s\"", out_file);
+            ret = 1;
+        }
+    }
+
+    return ret;
+}
+
+#ifdef _MAIN_BAM2DEPTH
+int main(int argc, char *argv[])
+{
+    return main_depth(argc, argv);
+}
+#endif

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_addrprg.c

@@ -0,0 +1,499 @@
+/* bam_addrprg.c -- samtools command to add or replace readgroups.
+
+   Copyright (c) 2013, 2015-2017, 2019-2021 Genome Research Limited.
+
+   Author: Martin O. Pollard <mp15@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <htslib/sam.h>
+#include <htslib/kstring.h>
+#include "samtools.h"
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <assert.h>
+#include <unistd.h>
+
+typedef enum {
+    overwrite_all,
+    orphan_only,
+} rg_mode;
+
+struct parsed_opts {
+    char* input_name;
+    char* output_name;
+    char* rg_id;
+    char* rg_line;
+    int no_pg;
+    rg_mode mode;
+    sam_global_args ga;
+    htsThreadPool p;
+    int uncompressed;
+    int overwrite_hdr_rg;
+};
+
+struct state;
+typedef struct parsed_opts parsed_opts_t;
+typedef struct state state_t;
+
+struct state {
+    samFile* input_file;
+    sam_hdr_t* input_header;
+    samFile* output_file;
+    sam_hdr_t* output_header;
+    char* rg_id;
+    void (*mode_func)(const state_t*, bam1_t*);
+};
+
+static void cleanup_opts(parsed_opts_t* opts)
+{
+    if (!opts) return;
+    free(opts->rg_id);
+    free(opts->output_name);
+    free(opts->input_name);
+    free(opts->rg_line);
+    if (opts->p.pool) hts_tpool_destroy(opts->p.pool);
+    sam_global_args_free(&opts->ga);
+    free(opts);
+}
+
+static void cleanup_state(state_t* state)
+{
+    if (!state) return;
+    free(state->rg_id);
+    if (state->output_file) sam_close(state->output_file);
+    sam_hdr_destroy(state->output_header);
+    if (state->input_file) sam_close(state->input_file);
+    sam_hdr_destroy(state->input_header);
+    free(state);
+}
+
+// Converts \t and \n into real tabs and newlines
+static char* basic_unescape(const char* in)
+{
+    assert(in);
+    char *ptr, *out;
+    out = ptr = malloc(strlen(in)+1);
+    size_t size = 0;
+    while (*in) {
+        if (*in == '\\') {
+            ++in;
+            if (*in == '\0') {
+                fprintf(stderr, "[%s] Unterminated escape sequence.\n", __func__);
+                free(out);
+                return NULL;
+            }
+            switch (*in) {
+            case '\\':
+                *ptr = '\\';
+                break;
+            case 't':
+                *ptr = '\t';
+                break;
+            case 'n':
+                fprintf(stderr, "[%s] \\n in escape sequence is not supported.\n", __func__);
+                free(out);
+                return NULL;
+            default:
+                fprintf(stderr, "[%s] Unsupported escape sequence.\n", __func__);
+                free(out);
+                return NULL;
+            }
+        } else {
+            *ptr = *in;
+        }
+        ++in;
+        ++ptr;
+        ++size;
+    }
+    *ptr = '\0';
+    ++size;
+    char* tmp = (char*)realloc(out, size);
+    if (!tmp) {
+        free(out);
+    }
+    return tmp;
+}
+
+// Malloc a string containing [s,slim) or to the end of s if slim is NULL.
+// If lenp is non-NULL, stores the length of the resulting string there.
+static char *dup_substring(const char *s, const char *slim, size_t *lenp)
+{
+    size_t len = slim? (slim - s) : strlen(s);
+    char *ns = malloc(len+1);
+    if (ns == NULL) return NULL;
+    memcpy(ns, s, len);
+    ns[len] = '\0';
+    if (lenp) *lenp = len;
+    return ns;
+}
+
+
+// Given a @RG line return the id
+static char* get_rg_id(const char *line)
+{
+    const char *id = strstr(line, "\tID:");
+    if (! id) return NULL;
+
+    id += 4;
+    return dup_substring(id, strchr(id, '\t'), NULL);
+}
+
+
+static void usage(FILE *fp)
+{
+    fprintf(fp,
+            "Usage: samtools addreplacerg [options] [-r <@RG line> | -R <existing id>] [-m orphan_only|overwrite_all] [-o <output.bam>] <input.bam>\n"
+            "\n"
+            "Options:\n"
+            "  -m MODE   Set the mode of operation from one of overwrite_all, orphan_only [overwrite_all]\n"
+            "  -o FILE   Where to write output to [stdout]\n"
+            "  -r STRING @RG line text\n"
+            "  -R STRING ID of @RG line in existing header to use\n"
+            "  -u        Output uncompressed data\n"
+            "  -w        Overwrite an existing @RG line\n"
+            "  --no-PG   Do not add a PG line\n"
+            );
+    sam_global_opt_help(fp, "..O..@..");
+}
+
+static bool parse_args(int argc, char** argv, parsed_opts_t** opts)
+{
+    *opts = NULL;
+    int n;
+
+    if (argc == 1) { usage(stdout); return true; }
+
+    parsed_opts_t* retval = calloc(1, sizeof(parsed_opts_t));
+    if (! retval ) {
+        fprintf(stderr, "[%s] Out of memory allocating parsed_opts_t\n", __func__);
+        return false;
+    }
+    // Set defaults
+    retval->mode = overwrite_all;
+    sam_global_args_init(&retval->ga);
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS(0, 0, 'O', 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+    kstring_t rg_line = {0,0,NULL};
+
+    while ((n = getopt_long(argc, argv, "r:R:m:o:O:h@:uw", lopts, NULL)) >= 0) {
+        switch (n) {
+            case 'r':
+                // Are we adding to existing rg line?
+                if (ks_len(&rg_line) == 0) {
+                    if (strlen(optarg)<3 || (optarg[0] != '@' && optarg[1] != 'R' && optarg[2] != 'G')) {
+                        kputs("@RG\t", &rg_line);
+                    }
+                } else {
+                    kputs("\t", &rg_line);
+                }
+                kputs(optarg, &rg_line);
+                break;
+            case 'R':
+                retval->rg_id = strdup(optarg);
+                break;
+            case 'm': {
+                if (strcmp(optarg, "overwrite_all") == 0) {
+                    retval->mode = overwrite_all;
+                } else if (strcmp(optarg, "orphan_only") == 0) {
+                    retval->mode = orphan_only;
+                } else {
+                    usage(stderr);
+                    return false;
+                }
+                break;
+            }
+            case 'o':
+                retval->output_name = strdup(optarg);
+                break;
+            case 'h':
+                usage(stdout);
+                free(retval);
+                return true;
+            case 1:
+                retval->no_pg = 1;
+                break;
+            case 'u':
+                retval->uncompressed = 1;
+                break;
+            case 'w':
+                retval->overwrite_hdr_rg = 1;
+                break;
+            case '?':
+                usage(stderr);
+                free(retval);
+                return false;
+            case 'O':
+            default:
+                if (parse_sam_global_opt(n, optarg, lopts, &retval->ga) == 0) break;
+                usage(stderr);
+                free(retval);
+                return false;
+        }
+    }
+    retval->rg_line = ks_release(&rg_line);
+
+    if (argc-optind < 1) {
+        fprintf(stderr, "You must specify an input file.\n");
+        usage(stderr);
+        cleanup_opts(retval);
+        return false;
+    }
+    if (retval->rg_id && retval->rg_line) {
+        fprintf(stderr, "The options -r and -R are mutually exclusive.\n");
+        cleanup_opts(retval);
+        return false;
+    }
+
+    if (retval->rg_line)
+    {
+        char* tmp = basic_unescape(retval->rg_line);
+
+        if ((retval->rg_id = get_rg_id(tmp)) == NULL) {
+            fprintf(stderr, "[%s] The supplied RG line lacks an ID tag.\n", __func__);
+            free(tmp);
+            cleanup_opts(retval);
+            return false;
+        }
+        free(retval->rg_line);
+        retval->rg_line = tmp;
+    }
+    retval->input_name = strdup(argv[optind+0]);
+
+    if (retval->ga.nthreads > 0) {
+        if (!(retval->p.pool = hts_tpool_init(retval->ga.nthreads))) {
+            fprintf(stderr, "Error creating thread pool\n");
+            return false;
+        }
+    }
+
+    *opts = retval;
+    return true;
+}
+
+static void overwrite_all_func(const state_t* state, bam1_t* file_read)
+{
+    uint8_t* data = (uint8_t*)strdup(state->rg_id);
+    int len = strlen(state->rg_id)+1;
+    // If the old exists delete it
+    uint8_t* old = bam_aux_get(file_read, "RG");
+    if (old != NULL) {
+        bam_aux_del(file_read, old);
+    }
+
+    bam_aux_append(file_read, "RG", 'Z', len, data);
+    free(data);
+}
+
+static void orphan_only_func(const state_t* state, bam1_t* file_read)
+{
+    uint8_t* data = (uint8_t*)strdup(state->rg_id);
+    int len = strlen(state->rg_id)+1;
+    // If the old exists don't do anything
+    uint8_t* old = bam_aux_get(file_read, "RG");
+    if (old == NULL) {
+        bam_aux_append(file_read, "RG",'Z',len,data);
+    }
+    free(data);
+}
+
+static bool init(const parsed_opts_t* opts, state_t** state_out) {
+    char output_mode[9] = "w";
+    state_t* retval = (state_t*) calloc(1, sizeof(state_t));
+
+    if (retval == NULL) {
+        fprintf(stderr, "[init] Out of memory allocating state struct.\n");
+        return false;
+    }
+    *state_out = retval;
+
+    // Open files
+    retval->input_file = sam_open_format(opts->input_name, "r", &opts->ga.in);
+    if (retval->input_file == NULL) {
+        print_error_errno("addreplacerg", "could not open \"%s\"", opts->input_name);
+        return false;
+    }
+    retval->input_header = sam_hdr_read(retval->input_file);
+
+    retval->output_header = sam_hdr_dup(retval->input_header);
+
+    if (opts->uncompressed)
+        strcat(output_mode, "0");
+    if (opts->output_name) // File format auto-detection
+        sam_open_mode(output_mode + strlen(output_mode),
+                      opts->output_name, NULL);
+    retval->output_file = sam_open_format(opts->output_name == NULL?"-":opts->output_name, output_mode, &opts->ga.out);
+
+    if (retval->output_file == NULL) {
+        print_error_errno("addreplacerg", "could not create \"%s\"", opts->output_name);
+        return false;
+    }
+
+    if (opts->p.pool) {
+        hts_set_opt(retval->input_file,  HTS_OPT_THREAD_POOL, &opts->p);
+        hts_set_opt(retval->output_file, HTS_OPT_THREAD_POOL, &opts->p);
+    }
+
+    if (opts->rg_line) {
+        // Append new RG line to header.
+        // Check does not already exist
+        kstring_t hdr_line = { 0, 0, NULL };
+        if (sam_hdr_find_line_id(retval->output_header, "RG", "ID", opts->rg_id, &hdr_line) == 0) {
+            if (opts->overwrite_hdr_rg) {
+                if(-1 == sam_hdr_remove_line_id(retval->output_header, "RG", "ID", opts->rg_id)) {
+                    fprintf(stderr, "[init] Error removing the RG line with ID:%s from the output header.\n", opts->rg_id);
+                    ks_free(&hdr_line);
+                    return false;
+                }
+            } else {
+                fprintf(stderr, "[init] RG line with ID:%s already present in the header. Use -w to overwrite.\n", opts->rg_id);
+                ks_free(&hdr_line);
+                return false;
+            }
+        }
+        ks_free(&hdr_line);
+
+        if (-1 == sam_hdr_add_lines(retval->output_header, opts->rg_line, strlen(opts->rg_line))) {
+            fprintf(stderr, "[init] Error adding RG line with ID:%s to the output header.\n", opts->rg_id);
+            return false;
+        }
+        if (opts->mode == overwrite_all &&
+            -1 == sam_hdr_remove_except(retval->output_header, "RG", "ID", opts->rg_id)) {
+            fprintf(stderr, "[init] Error removing the old RG lines from the output header.\n");
+            return false;
+        }
+        retval->rg_id = strdup(opts->rg_id);
+    } else {
+        if (opts->rg_id) {
+            // Confirm what has been supplied exists
+            kstring_t hdr_line = { 0, 0, NULL };
+            if (sam_hdr_find_line_id(retval->output_header, "RG", "ID", opts->rg_id, &hdr_line) < 0) {
+                fprintf(stderr, "RG ID supplied does not exist in header. Supply full @RG line with -r instead?\n");
+                return false;
+            }
+            retval->rg_id = strdup(opts->rg_id);
+            ks_free(&hdr_line);
+        } else {
+            kstring_t rg_id = { 0, 0, NULL };
+            if (sam_hdr_find_tag_id(retval->output_header, "RG", NULL, NULL, "ID", &rg_id) < 0) {
+                fprintf(stderr, "No RG specified on command line or in existing header.\n");
+                return false;
+            }
+            retval->rg_id = ks_release(&rg_id);
+        }
+    }
+
+    switch (opts->mode) {
+        case overwrite_all:
+            retval->mode_func = &overwrite_all_func;
+            break;
+        case orphan_only:
+            retval->mode_func = &orphan_only_func;
+            break;
+    }
+
+    return true;
+}
+
+static bool readgroupise(parsed_opts_t *opts, state_t* state, char *arg_list)
+{
+    if (!opts->no_pg && sam_hdr_add_pg(state->output_header, "samtools",
+                                       "VN", samtools_version(),
+                                       arg_list ? "CL": NULL,
+                                       arg_list ? arg_list : NULL,
+                                       NULL))
+        return false;
+
+    if (sam_hdr_write(state->output_file, state->output_header) != 0) {
+        print_error_errno("addreplacerg", "[%s] Could not write header to output file", __func__);
+        return false;
+    }
+    char *idx_fn = NULL;
+    if (opts->ga.write_index) {
+        if (!(idx_fn = auto_index(state->output_file, opts->output_name, state->output_header)))
+            return false;
+    }
+
+    bam1_t* file_read = bam_init1();
+    int ret;
+    while ((ret = sam_read1(state->input_file, state->input_header, file_read)) >= 0) {
+        state->mode_func(state, file_read);
+
+        if (sam_write1(state->output_file, state->output_header, file_read) < 0) {
+            print_error_errno("addreplacerg", "[%s] Could not write read to output file", __func__);
+            bam_destroy1(file_read);
+            free(idx_fn);
+            return false;
+        }
+    }
+    bam_destroy1(file_read);
+    if (ret != -1) {
+        print_error_errno("addreplacerg", "[%s] Error reading from input file", __func__);
+        free(idx_fn);
+        return false;
+    } else {
+
+        if (opts->ga.write_index) {
+            if (sam_idx_save(state->output_file) < 0) {
+                print_error_errno("addreplacerg", "[%s] Writing index failed", __func__);
+                free(idx_fn);
+                return false;
+            }
+        }
+        free(idx_fn);
+        return true;
+    }
+}
+
+int main_addreplacerg(int argc, char** argv)
+{
+    parsed_opts_t* opts = NULL;
+    state_t* state = NULL;
+    char *arg_list = stringify_argv(argc+1, argv-1);
+    if (!arg_list)
+        return EXIT_FAILURE;
+
+    if (!parse_args(argc, argv, &opts)) goto error;
+    if (opts) { // Not an error but user doesn't want us to proceed
+        if (!init(opts, &state) || !readgroupise(opts, state, arg_list))
+            goto error;
+    }
+
+    cleanup_state(state);
+    cleanup_opts(opts);
+    free(arg_list);
+
+    return EXIT_SUCCESS;
+error:
+    cleanup_state(state);
+    cleanup_opts(opts);
+    free(arg_list);
+
+    return EXIT_FAILURE;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_ampliconclip.c

@@ -0,0 +1,1117 @@
+/*  bam_ampliconclip.c -- loads amplicon primers from a BED file and cuts reads
+                          from the 5' end.
+
+    Copyright (C) 2020-2023 Genome Research Ltd.
+
+    Authors: Andrew Whitwham <aw7@sanger.ac.uk>
+             Rob Davies <rmd+git@sanger.ac.uk>
+
+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
+*/
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include <htslib/hts.h>
+#include "htslib/hfile.h"
+#include "htslib/kstring.h"
+#include "htslib/sam.h"
+#include "samtools.h"
+#include "bam_ampliconclip.h"
+
+typedef enum {
+    soft_clip,
+    hard_clip
+} clipping_type;
+
+typedef struct {
+    int add_pg;
+    int use_strand;
+    int write_clipped;
+    int mark_fail;
+    int both;
+    int fail_len;
+    int filter_len;
+    int unmapped;
+    int oa_tag;
+    int del_tag;
+    int tol;
+    int unmap_len;
+    char *arg_list;
+    char *stats_file;
+    char *rejects_file;
+} cl_param_t;
+
+
+static int bed_entry_sort(const void *av, const void *bv) {
+    bed_entry_t *a = (bed_entry_t *) av;
+    bed_entry_t *b = (bed_entry_t *) bv;
+    return a->right < b->right ? -1 : (a->right == b->right ? 0 : 1);
+}
+
+
+int load_bed_file_multi_ref(char *infile, int get_strand, int sort_by_pos, khash_t(bed_list_hash) *bed_lists) {
+    hFILE *fp;
+    int line_count = 0, ret;
+    int64_t left, right;
+    kstring_t line = KS_INITIALIZE;
+    bed_entry_list_t *list;
+    khiter_t bed_itr;
+
+    if ((fp = hopen(infile, "r")) == NULL) {
+        print_error_errno("amplicon", "unable to open file %s.", infile);
+        return 1;
+    }
+
+    char ref[1024];
+
+    while (line.l = 0, kgetline(&line, (kgets_func *)hgets, fp) >= 0) {
+        line_count++;
+        int hret;
+        char strand;
+
+        if (line.l == 0 || *line.s == '#') continue;
+        if (strncmp(line.s, "track ", 6) == 0) continue;
+        if (strncmp(line.s, "browser ", 8) == 0) continue;
+
+        if (get_strand) {
+            if (sscanf(line.s, "%1023s %"SCNd64" %"SCNd64" %*s %*s %c",
+                       ref, &left, &right, &strand) != 4) {
+                fprintf(stderr, "[amplicon] error: bad bed file format in line %d of %s.\n"
+                                "(N.B. ref/chrom name limited to 1023 characters.)\n",
+                                    line_count, infile);
+                ret = 1;
+                goto error;
+            }
+        } else {
+            if (sscanf(line.s, "%1023s %"SCNd64" %"SCNd64,
+                       ref, &left, &right) != 3) {
+                fprintf(stderr, "[amplicon] error: bad bed file format in line %d of %s\n"
+                                "(N.B. ref/chrom name limited to 1023 characters.)\n",
+                                    line_count, infile);
+                ret = 1;
+                goto error;
+            }
+        }
+
+        bed_itr = kh_get(bed_list_hash, bed_lists, ref);
+
+        if (bed_itr == kh_end(bed_lists)) { // new ref entry
+            char *ref_name = strdup(ref); // need a copy for the hash key
+
+            if (!ref_name) {
+                fprintf(stderr, "[amplicon] error: unable to allocate memory for ref name.\n");
+                ret = 1;
+                goto error;
+            }
+
+            bed_itr = kh_put(bed_list_hash, bed_lists, ref_name, &hret);
+
+            if (hret > 0) {
+                list = &kh_val(bed_lists, bed_itr);
+
+                // initialise the new hash entry
+                list->longest = 0;
+                list->size = 0;
+                list->length = 0;
+                list->bp = NULL;
+            } else {
+                fprintf(stderr, "[amplicon] error: ref hashing failure.\n");
+                ret = 1;
+                goto error;
+            }
+        } else { // existing ref
+            list = &kh_val(bed_lists, bed_itr);
+        }
+
+        if (list->length == list->size) {
+           bed_entry_t *tmp;
+
+           list->size += list->size / 2 + 256;
+
+           if ((tmp = realloc(list->bp, list->size * sizeof(bed_entry_t))) == NULL) {
+               fprintf(stderr, "[amplicon] error: unable to allocate more memory for bed data.\n");
+               ret = 1;
+               goto error;
+           }
+
+           list->bp = tmp;
+        }
+
+        list->bp[list->length].left  = left;
+        list->bp[list->length].right = right;
+
+        if (get_strand) {
+            if (strand == '+') {
+                list->bp[list->length].rev = 0;
+            } else if (strand == '-') {
+                list->bp[list->length].rev = 1;
+            } else {
+                fprintf(stderr, "[amplicon] error: bad strand value in line %d, expecting '+' or '-', found '%c'.\n",
+                            line_count, strand);
+                ret = 1;
+                goto error;
+            }
+        }
+
+        if (right - left > list->longest)
+            list->longest = right - left;
+
+        list->length++;
+    }
+
+    if (sort_by_pos) {
+        for (bed_itr = kh_begin(bed_lists); bed_itr != kh_end(bed_lists); ++bed_itr) {
+            if (kh_exist(bed_lists, bed_itr)) {
+                list = &kh_val(bed_lists, bed_itr);
+                qsort(list->bp, list->length, sizeof(list->bp[0]), bed_entry_sort);
+            }
+        }
+    }
+
+    if (kh_size(bed_lists) > 0) {// any entries
+        ret = 0;
+    } else {
+        ret = 1;
+    }
+
+error:
+    ks_free(&line);
+
+    if (hclose(fp) != 0) {
+        fprintf(stderr, "[amplicon] warning: failed to close %s", infile);
+    }
+
+    return ret;
+}
+
+
+void destroy_bed_hash(khash_t(bed_list_hash) *hash) {
+    khiter_t itr;
+
+    for (itr = kh_begin(hash); itr != kh_end(hash); ++itr) {
+       if (kh_exist(hash, itr)) {
+           free(kh_val(hash, itr).bp);
+           free((char *)kh_key(hash, itr));
+           kh_key(hash, itr) = NULL;
+        }
+    }
+
+    kh_destroy(bed_list_hash, hash);
+}
+
+
+static int matching_clip_site(bed_entry_list_t *sites, hts_pos_t pos,
+                              int is_rev, int use_strand, int64_t longest,
+                              cl_param_t *param) {
+    int i, size;  // may need this to be variable
+    int tol = param->tol;
+    int l = 0, mid = sites->length / 2, r = sites->length;
+    int pos_tol = is_rev ? (pos > tol ? pos - tol : 0) : pos;
+
+    while (r - l > 1) {
+        if (sites->bp[mid].right <= pos_tol) {
+            l = mid;
+        } else {
+            r = mid;
+        }
+        mid = (l + r) / 2;
+    }
+
+    size = 0;
+
+    for (i = l; i < sites->length; i++) {
+        hts_pos_t mod_left, mod_right;
+
+        if (use_strand && is_rev != sites->bp[i].rev)
+            continue;
+
+        if (is_rev) {
+            mod_left = sites->bp[i].left;
+            mod_right = sites->bp[i].right + tol;
+        } else {
+            if (sites->bp[i].left > tol) {
+                mod_left = sites->bp[i].left - tol;
+            } else {
+                mod_left = 0;
+            }
+            mod_right = sites->bp[i].right;
+        }
+
+        if (pos + longest + tol < mod_right)
+            break;
+
+        if (pos >= mod_left && pos <= mod_right) {
+            if (is_rev) {
+                if (size < pos - sites->bp[i].left) {
+                    size = pos - sites->bp[i].left;
+                }
+            } else {
+                if (size < sites->bp[i].right - pos) {
+                    size = sites->bp[i].right - pos;
+                }
+            }
+        }
+    }
+
+    return size;
+}
+
+
+static int bam_trim_left(bam1_t *rec, bam1_t *rec_out, uint32_t bases,
+                         clipping_type clipping) {
+    uint32_t *orig_cigar = bam_get_cigar(rec);
+    uint8_t *orig_seq = bam_get_seq(rec);
+    uint8_t *orig_qual = bam_get_qual(rec);
+    uint8_t *orig_aux = bam_get_aux(rec);
+    uint32_t *new_cigar;
+    uint8_t *new_qual;
+    size_t orig_l_aux = bam_get_l_aux(rec);
+    uint32_t i, j;
+    uint32_t ref_remove = bases, qry_removed = 0, hardclip = 0;
+    hts_pos_t new_pos = rec->core.pos;
+    uint32_t cig_type, cig_op;
+
+    if (rec->l_data + 8 > rec_out->m_data) {
+        uint8_t *new_data = realloc(rec_out->data, rec->l_data + 8);
+        if (!new_data) {
+            fprintf(stderr, "[ampliconclip] error: could not allocate memoy for new bam record\n");
+            return 1;
+        }
+        rec_out->data = new_data;
+        rec_out->m_data = rec->l_data + 8;
+    }
+
+    // Copy core data & name
+    memcpy(&rec_out->core, &rec->core, sizeof(rec->core));
+    memcpy(rec_out->data, rec->data, rec->core.l_qname);
+
+    // Modify CIGAR
+    new_cigar = bam_get_cigar(rec_out);
+
+    for (i = 0;  i < rec->core.n_cigar; i++) {
+        cig_op = bam_cigar_op(orig_cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if (cig_op == BAM_CHARD_CLIP) {
+            hardclip += bam_cigar_oplen(orig_cigar[i]);
+        } else {
+            if (cig_type & 2) {
+                if (bam_cigar_oplen(orig_cigar[i]) <= ref_remove) {
+                    ref_remove -= bam_cigar_oplen(orig_cigar[i]);
+                } else {
+                    break;
+                }
+                new_pos += bam_cigar_oplen(orig_cigar[i]);
+            }
+            if (cig_type & 1) {
+                qry_removed += bam_cigar_oplen(orig_cigar[i]);
+            }
+        }
+    }
+
+    if (i < rec->core.n_cigar) {
+        cig_type = bam_cigar_type(bam_cigar_op(orig_cigar[i]));
+
+        // account for the last operation
+        if (cig_type & 2) {
+            new_pos += ref_remove;
+        }
+        if (cig_type & 1) {
+            qry_removed += ref_remove;
+        }
+    } else {
+        if (clipping == hard_clip) {
+
+            rec_out->core.l_qseq = 0;
+            rec_out->core.n_cigar = 0;
+
+            if (orig_l_aux)
+                memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+            rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+            return 0;
+        }
+
+        qry_removed = rec->core.l_qseq;
+    }
+
+    j = 0;
+    if (clipping == hard_clip && hardclip + qry_removed > 0) {
+        new_cigar[j++] = bam_cigar_gen(hardclip + qry_removed, BAM_CHARD_CLIP);
+    }
+    if (clipping == soft_clip) {
+        if (hardclip > 0) {
+            new_cigar[j++] = bam_cigar_gen(hardclip, BAM_CHARD_CLIP);
+        }
+        if (qry_removed > 0) {
+            new_cigar[j++] = bam_cigar_gen(qry_removed, BAM_CSOFT_CLIP);
+        }
+    }
+
+    if (i < rec->core.n_cigar
+        && bam_cigar_oplen(orig_cigar[i]) > ref_remove) {
+        new_cigar[j++] = bam_cigar_gen(bam_cigar_oplen(orig_cigar[i]) - ref_remove, bam_cigar_op(orig_cigar[i]));
+
+        // fill in the rest of the cigar
+        i++;
+
+        for (; i < rec->core.n_cigar; i++) {
+            new_cigar[j++] = orig_cigar[i];
+        }
+    }
+
+    rec_out->core.n_cigar = j;
+
+    if (clipping == soft_clip) {
+        qry_removed = 0; // Copy all the sequence and confidence values
+    }
+
+    new_qual = bam_get_seq(rec_out) + (rec->core.l_qseq - qry_removed + 1) / 2;
+    // Copy remaining SEQ
+    if ((qry_removed & 1) == 0) {
+        memcpy(bam_get_seq(rec_out), orig_seq + (qry_removed / 2),
+                (rec->core.l_qseq - qry_removed + 1) / 2); // +1 to account for odd numbers
+    } else {
+        uint8_t *in = orig_seq + qry_removed / 2;
+        uint8_t *out = bam_get_seq(rec_out);
+        uint32_t i;
+        for (i = qry_removed; i < rec->core.l_qseq - 1; i += 2) {
+            *out++ = ((in[0] & 0x0f) << 4) | ((in[1] & 0xf0) >> 4);
+            in++;
+        }
+        if (i < rec->core.l_qseq) {
+            *out++ = (in[0] & 0x0f) << 4;
+        }
+        assert(out == new_qual);
+    }
+
+    // Copy remaining QUAL
+    memmove(new_qual, orig_qual, rec->core.l_qseq - qry_removed);
+
+    // Set new l_qseq
+    rec_out->core.l_qseq -= qry_removed;
+
+    // Move AUX
+    if (orig_l_aux)
+        memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+    // Set new l_data
+    rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+    // put in new pos
+    rec_out->core.pos = new_pos;
+
+    return 0;
+}
+
+
+static int bam_trim_right(bam1_t *rec, bam1_t *rec_out, uint32_t bases,
+                          clipping_type clipping) {
+    uint32_t *orig_cigar = bam_get_cigar(rec);
+    uint8_t *orig_seq = bam_get_seq(rec);
+    uint8_t *orig_qual = bam_get_qual(rec);
+    uint8_t *orig_aux = bam_get_aux(rec);
+    uint32_t *new_cigar;
+    uint32_t new_n_cigar = 0;
+    uint8_t *new_qual;
+    size_t orig_l_aux = bam_get_l_aux(rec);
+    int32_t i;
+    int32_t j;
+    uint32_t ref_remove = bases, qry_removed = 0, hardclip = 0;
+    uint32_t cig_type, cig_op;
+
+    if (rec->l_data + 8 > rec_out->m_data) {
+        uint8_t *new_data = realloc(rec_out->data, rec->l_data + 8);
+        if (!new_data) {
+            fprintf(stderr, "[ampliconclip] error: could not allocate memoy for new bam record\n");
+            return 1;
+        }
+        rec_out->data = new_data;
+        rec_out->m_data = rec->l_data + 8;
+    }
+
+    // Copy core data & name
+    memcpy(&rec_out->core, &rec->core, sizeof(rec->core));
+    memcpy(rec_out->data, rec->data, rec->core.l_qname);
+
+    // Modify CIGAR here
+    new_cigar = bam_get_cigar(rec_out);
+
+    for (i = rec->core.n_cigar - 1;  i >= 0; --i) {
+        cig_op = bam_cigar_op(orig_cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if (cig_op == BAM_CHARD_CLIP) {
+            hardclip += bam_cigar_oplen(orig_cigar[i]);
+        } else {
+            if (cig_type & 2) {
+                if (bam_cigar_oplen(orig_cigar[i]) <= ref_remove) {
+                    ref_remove -= bam_cigar_oplen(orig_cigar[i]);
+                } else {
+                    break;
+                }
+            }
+            if (cig_type & 1) {
+                qry_removed += bam_cigar_oplen(orig_cigar[i]);
+            }
+        }
+    }
+
+    if (i >= 0) {
+        cig_type = bam_cigar_type(bam_cigar_op(orig_cigar[i]));
+        if (cig_type & 1) {
+            qry_removed += ref_remove;
+        }
+        j = i;
+        if (qry_removed > 0) j++;
+        if (hardclip > 0 && (clipping == soft_clip || qry_removed == 0)) j++;
+    } else {
+        if (clipping == hard_clip) {
+
+            rec_out->core.l_qseq = 0;
+            rec_out->core.n_cigar = 0;
+
+            if (orig_l_aux)
+                memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+            rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+            return 0;
+        }
+
+        qry_removed = rec->core.l_qseq;
+        j = 0;
+        if (hardclip > 0 && clipping == soft_clip) j++;
+    }
+
+    if (clipping == hard_clip && hardclip + qry_removed > 0) {
+        new_cigar[j] = bam_cigar_gen(hardclip + qry_removed, BAM_CHARD_CLIP);
+        new_n_cigar++;
+    }
+    if (clipping == soft_clip) {
+        if (hardclip > 0) {
+            new_cigar[j] = bam_cigar_gen(hardclip, BAM_CHARD_CLIP);
+            new_n_cigar++;
+            if (qry_removed > 0) --j;
+        }
+        if (qry_removed > 0) {
+            new_cigar[j] = bam_cigar_gen(qry_removed, BAM_CSOFT_CLIP);
+            new_n_cigar++;
+        }
+    }
+
+    if (j > 0) {
+        new_cigar[--j] = bam_cigar_gen(bam_cigar_oplen(orig_cigar[i]) - ref_remove, bam_cigar_op(orig_cigar[i]));
+        new_n_cigar++;
+    }
+
+    // fill in the rest of the cigar
+    while (j > 0) {
+        new_cigar[--j] = orig_cigar[--i];
+        new_n_cigar++;
+    }
+
+    rec_out->core.n_cigar = new_n_cigar;
+
+    if (clipping == soft_clip)
+        qry_removed = 0; // Copy all the sequence and confidence values
+
+    new_qual = bam_get_seq(rec_out) + (rec->core.l_qseq - qry_removed + 1) / 2;
+    // Copy remaining SEQ
+    memcpy(bam_get_seq(rec_out), orig_seq, (rec->core.l_qseq - qry_removed + 1) / 2);
+
+    // Copy remaining QUAL
+    memcpy(new_qual, orig_qual, rec->core.l_qseq - qry_removed);
+
+    // Set new l_qseq
+    rec_out->core.l_qseq -= qry_removed;
+
+    // Copy AUX
+    if (orig_l_aux)
+        memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+    // Set new l_data
+    rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+    return 0;
+}
+
+
+static hts_pos_t active_query_len(bam1_t *b) {
+    uint32_t *cigar = bam_get_cigar(b);
+    uint32_t cig_type, cig_op;
+    hts_pos_t len = 0;
+    int i;
+
+    for (i = 0; i < b->core.n_cigar; i++) {
+        cig_op =  bam_cigar_op(cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if ((cig_type & 1) && (cig_op != BAM_CSOFT_CLIP)) {
+            len += bam_cigar_oplen(cigar[i]);
+        }
+    }
+
+    return len;
+}
+
+
+static inline void swap_bams(bam1_t **a, bam1_t **b) {
+    bam1_t *tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+
+// Format OA:Z:(RNAME,POS,strand,CIGAR,MAPQ,NM;
+static inline int tag_original_data(bam1_t *orig, kstring_t *oa_tag) {
+    char strand;
+    uint8_t *nm_tag, *old_oa_tag;
+    uint32_t *cigar;
+    int64_t nm = 0;
+    int i, res = 0;
+
+    ks_clear(oa_tag);
+
+    // if there is an existing OA tag the new one gets appended to it
+    if ((old_oa_tag = bam_aux_get(orig, "OA"))) {
+        res |= ksprintf(oa_tag, "%s", bam_aux2Z(old_oa_tag)) < 0;
+    }
+
+    if (orig->core.flag & BAM_FREVERSE)
+        strand = '-';
+    else
+        strand = '+';
+
+    if ((nm_tag = bam_aux_get(orig, "NM"))) {
+        nm = bam_aux2i(nm_tag);
+    }
+
+    res |= ksprintf(oa_tag, "%s,%"PRIhts_pos",%c,", bam_get_qname(orig), orig->core.pos + 1, strand) < 0;
+
+    for (i = 0, cigar = bam_get_cigar(orig); i < orig->core.n_cigar && res == 0; ++i) {
+        res |= kputw(bam_cigar_oplen(cigar[i]), oa_tag) < 0;
+        res |= kputc(bam_cigar_opchr(cigar[i]), oa_tag) < 0;
+    }
+
+    if (nm_tag) {
+        res |= ksprintf(oa_tag, ",%d,%"PRId64";", orig->core.qual, nm) < 0;
+    } else {
+        res |= ksprintf(oa_tag, "%d,;", orig->core.qual) < 0;
+    }
+
+    return res;
+}
+
+
+static int bam_clip(samFile *in, samFile *out, samFile *reject, char *bedfile,
+                    clipping_type clipping, cl_param_t *param) {
+    int ret = 1, r, file_open = 0;
+
+    bam_hdr_t *header = NULL;
+    bam1_t *b = NULL, *b_tmp = NULL;
+    long f_count = 0, r_count = 0, n_count = 0, l_count = 0, l_exclude = 0, b_count = 0;
+    long filtered = 0, written = 0, failed = 0;
+    kstring_t str = KS_INITIALIZE;
+    kstring_t oat = KS_INITIALIZE;
+    kstring_t seq = KS_INITIALIZE;
+    bed_entry_list_t *sites;
+    FILE *stats_fp = stderr;
+    khash_t(bed_list_hash) *bed_hash = kh_init(bed_list_hash);
+
+    if (load_bed_file_multi_ref(bedfile, param->use_strand, 1, bed_hash)) {
+        fprintf(stderr, "[ampliconclip] error: unable to load bed file.\n");
+        goto fail;
+    }
+
+    if ((header = sam_hdr_read(in)) == NULL) {
+        fprintf(stderr, "[ampliconclip] error: could not read header\n");
+        goto fail;
+    }
+
+    // changing pos can ruin coordinate sort order
+    if (sam_hdr_find_tag_hd(header, "SO", &str) == 0 && str.s && strcmp(str.s, "coordinate") == 0) {
+        const char *new_order = "unknown";
+
+        if (sam_hdr_update_hd(header, "SO", new_order) == -1) {
+            fprintf(stderr, "[ampliconclip] error: unable to change sort order to 'SO:%s'\n", new_order);
+            goto fail;
+        }
+    }
+
+    ks_free(&str);
+
+    if (param->add_pg && sam_hdr_add_pg(header, "samtools", "VN", samtools_version(),
+                        param->arg_list ? "CL" : NULL,
+                        param->arg_list ? param->arg_list : NULL,
+                        NULL) != 0) {
+        fprintf(stderr, "[ampliconclip] warning: unable to add @PG line to header.\n");
+    }
+    if (sam_hdr_write(out, header) < 0) {
+        fprintf(stderr, "[ampliconclip] error: could not write header.\n");
+        goto fail;
+    }
+
+    if (reject) {
+       if (sam_hdr_write(reject, header) < 0) {
+           fprintf(stderr, "[ampliconclip] error: could not write header to rejects file.\n");
+           goto fail;
+       }
+    }
+
+    b = bam_init1();
+    b_tmp = bam_init1();
+    if (!b || !b_tmp) {
+        fprintf(stderr, "[ampliconclip] error: out of memory when trying to create record.\n");
+        goto fail;
+    }
+
+    int32_t last_tid = -1;
+    int ref_found = 0;
+
+    while ((r = sam_read1(in, header, b)) >= 0) {
+        hts_pos_t pos;
+        int is_rev;
+        int p_size;
+        int been_clipped  = 0, filter = 0;
+        int exclude = (BAM_FUNMAP | BAM_FQCFAIL);
+        khiter_t itr;
+
+        l_count++;
+
+        if (b->core.tid != last_tid) {
+            const char *ref_name;
+
+            ref_found = 0;
+            last_tid = b->core.tid;
+
+            if ((ref_name = sam_hdr_tid2name(header, b->core.tid)) != NULL) {
+                itr = kh_get(bed_list_hash, bed_hash, ref_name);
+
+                if (itr != kh_end(bed_hash)) {
+                    sites = &kh_val(bed_hash, itr);
+                    ref_found = 1;
+                }
+            }
+        }
+
+        if (!(b->core.flag & exclude) && ref_found) {
+            if (param->oa_tag)
+                if (tag_original_data(b, &oat))
+                    goto fail;
+
+            if (!param->both) {
+                if (bam_is_rev(b)) {
+                    pos = bam_endpos(b);
+                    is_rev = 1;
+                } else {
+                    pos = b->core.pos;
+                    is_rev = 0;
+                }
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (is_rev) {
+                        if (bam_trim_right(b, b_tmp, p_size, clipping) != 0)
+                            goto fail;
+
+                        swap_bams(&b, &b_tmp);
+                        r_count++;
+                    } else {
+                        if (bam_trim_left(b, b_tmp, p_size, clipping) != 0)
+                            goto fail;
+
+                        swap_bams(&b, &b_tmp);
+                        f_count++;
+                    }
+
+                    if (param->oa_tag) {
+                        if (bam_aux_update_str(b, "OA", oat.l + 1, (const char *)oat.s))
+                            goto fail;
+                    }
+
+                    if (param->del_tag) {
+                        uint8_t *tag;
+
+                        if ((tag = bam_aux_get(b, "NM")))
+                            bam_aux_del(b, tag);
+
+                        if ((tag = bam_aux_get(b, "MD")))
+                            bam_aux_del(b, tag);
+                    }
+
+                    been_clipped = 1;
+                } else {
+                    if (param->mark_fail) {
+                        b->core.flag |= BAM_FQCFAIL;
+                    }
+
+                    n_count++;
+                }
+            } else {
+                int left = 0, right = 0;
+
+                // left first
+                pos = b->core.pos;
+                is_rev = 0;
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (bam_trim_left(b, b_tmp, p_size, clipping) != 0)
+                        goto fail;
+
+                    swap_bams(&b, &b_tmp);
+                    f_count++;
+                    left = 1;
+                    been_clipped = 1;
+                }
+
+                // the right
+                pos = bam_endpos(b);
+                is_rev = 1;
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (bam_trim_right(b, b_tmp, p_size, clipping) != 0)
+                        goto fail;
+
+                    swap_bams(&b, &b_tmp);
+                    r_count++;
+                    right = 1;
+                    been_clipped = 1;
+                }
+
+                if (left || right) {
+                    uint8_t *tag;
+
+                    if (param->oa_tag) {
+                        if (bam_aux_update_str(b, "OA", oat.l + 1, (const char *)oat.s))
+                            goto fail;
+                    }
+
+                    if (param->del_tag) {
+                        if ((tag = bam_aux_get(b, "NM")))
+                            bam_aux_del(b, tag);
+
+                        if ((tag = bam_aux_get(b, "MD")))
+                            bam_aux_del(b, tag);
+                    }
+                }
+
+                if (left && right) {
+                    b_count++;
+                } else if (!left && !right) {
+                    if (param->mark_fail) {
+                        b->core.flag |= BAM_FQCFAIL;
+                    }
+
+                    n_count++;
+                }
+            }
+
+            if (param->fail_len >= 0 || param->filter_len >= 0 || param->unmap_len >= 0) {
+                hts_pos_t aql = active_query_len(b);
+
+                if (param->fail_len >= 0 && aql <= param->fail_len) {
+                    b->core.flag |= BAM_FQCFAIL;
+                }
+
+                if (param->filter_len >= 0 && aql <= param->filter_len) {
+                    filter = 1;
+                }
+
+                if (param->unmap_len >= 0 && aql <= param->unmap_len) {
+
+                    if (ks_resize(&seq, b->core.l_qseq) < 0) {
+                        fprintf(stderr, "[ampliconclip] error: allocate memory for sequence %s\n", bam_get_seq(b));
+                        goto fail;
+                    }
+
+                    ks_clear(&seq);
+                    char *sb = ks_str(&seq);
+                    uint8_t *sequence = bam_get_seq(b);
+                    int i;
+
+                    for (i = 0; i < b->core.l_qseq ; ++i) {
+                        *sb++ = seq_nt16_str[bam_seqi(sequence, i)];
+                    }
+
+                    if (bam_set1(b_tmp, b->core.l_qname - b->core.l_extranul - 1, bam_get_qname(b),
+                                 (b->core.flag | BAM_FUNMAP), b->core.tid, b->core.pos, 0,
+                                 0, NULL, b->core.mtid, b->core.mpos, b->core.isize,
+                                 b->core.l_qseq, seq.s, (const char *)bam_get_qual(b),
+                                 bam_get_l_aux(b)) < 0) {
+                        fprintf(stderr, "[ampliconclip] error: could not unmap read %s\n", bam_get_seq(b));
+                        goto fail;
+                    }
+
+                    memcpy(bam_get_aux(b_tmp), bam_get_aux(b), bam_get_l_aux(b));
+                    b_tmp->l_data += bam_get_l_aux(b);
+                    swap_bams(&b, &b_tmp);
+                }
+           }
+
+           if (b->core.flag & BAM_FQCFAIL) {
+               failed++;
+           }
+
+           if (param->write_clipped && !been_clipped) {
+               filter = 1;
+           }
+
+        } else {
+            l_exclude++;
+
+            if (param->unmapped) {
+                filter = 1;
+            }
+        }
+
+        if (!filter) {
+            if (sam_write1(out, header, b) < 0) {
+                fprintf(stderr, "[ampliconclip] error: could not write line %ld.\n", l_count);
+                goto fail;
+            }
+
+            written++;
+        } else {
+            if (reject) {
+                if (sam_write1(reject, header, b) < 0) {
+                    fprintf(stderr, "[ampliconclip] error: could not write to reject file %s\n",
+                            param->rejects_file);
+                    goto fail;
+                }
+            }
+
+            filtered++;
+        }
+    }
+
+    if (r < -1) {
+        fprintf(stderr, "[ampliconclip] error: failed to read input.\n");
+        goto fail;
+    }
+
+    if (param->stats_file) {
+        if ((stats_fp = fopen(param->stats_file, "w")) == NULL) {
+            fprintf(stderr, "[ampliconclip] warning: cannot write stats to %s.\n", param->stats_file);
+        } else {
+            file_open = 1;
+        }
+    }
+
+    fprintf(stats_fp, "COMMAND: %s\n"
+                    "TOTAL READS: %ld\n"
+                    "TOTAL CLIPPED: %ld\n"
+                    "FORWARD CLIPPED: %ld\n"
+                    "REVERSE CLIPPED: %ld\n"
+                    "BOTH CLIPPED: %ld\n"
+                    "NOT CLIPPED: %ld\n"
+                    "EXCLUDED: %ld\n"
+                    "FILTERED: %ld\n"
+                    "FAILED: %ld\n"
+                    "WRITTEN: %ld\n", param->arg_list, l_count, f_count + r_count,
+                                    f_count, r_count, b_count, n_count, l_exclude,
+                                    filtered, failed, written);
+
+    if (file_open) {
+        fclose(stats_fp);
+    }
+
+    ret = 0;
+
+fail:
+    destroy_bed_hash(bed_hash);
+    ks_free(&oat);
+    ks_free(&seq);
+    sam_hdr_destroy(header);
+    bam_destroy1(b);
+    bam_destroy1(b_tmp);
+    return ret;
+}
+
+
+static void usage(void) {
+    fprintf(stderr, "Usage: samtools ampliconclip -b BED file <input.bam> -o <output.bam>\n\n");
+    fprintf(stderr, "Option: \n");
+    fprintf(stderr, " -b  FILE            BED file of regions (eg amplicon primers) to be removed.\n");
+    fprintf(stderr, " -o  FILE            output file name (default stdout).\n");
+    fprintf(stderr, " -f  FILE            write stats to file name (default stderr)\n");
+    fprintf(stderr, " -u                  Output uncompressed data\n");
+    fprintf(stderr, " --soft-clip         soft clip amplicon primers from reads (default)\n");
+    fprintf(stderr, " --hard-clip         hard clip amplicon primers from reads.\n");
+    fprintf(stderr, " --both-ends         clip on both 5' and 3' ends.\n");
+    fprintf(stderr, " --strand            use strand data from BED file to match read direction.\n");
+    fprintf(stderr, " --clipped           only output clipped reads.\n");
+    fprintf(stderr, " --fail              mark unclipped, mapped reads as QCFAIL.\n");
+    fprintf(stderr, " --filter-len INT    do not output reads INT size or shorter.\n");
+    fprintf(stderr, " --fail-len   INT    mark as QCFAIL reads INT size or shorter.\n");
+    fprintf(stderr, " --unmap-len  INT    unmap reads INT size or shorter, default 0.\n");
+    fprintf(stderr, " --no-excluded       do not write excluded reads (unmapped or QCFAIL).\n");
+    fprintf(stderr, " --rejects-file FILE file to write filtered reads.\n");
+    fprintf(stderr, " --original          for clipped entries add an OA tag with original data.\n");
+    fprintf(stderr, " --keep-tag          for clipped entries keep the old NM and MD tags.\n");
+    fprintf(stderr, " --tolerance         match region within this number of bases, default 5.\n");
+    fprintf(stderr, " --no-PG             do not add an @PG line.\n");
+    sam_global_opt_help(stderr, "-.O..@-.");
+    fprintf(stderr, "\nAbout: Soft clips read alignments where they match BED file defined regions.\n"
+                    "Default clipping is only on the 5' end.\n\n");
+}
+
+
+int amplicon_clip_main(int argc, char **argv) {
+    int c, ret;
+    char wmode[4] = {'w', 'b', 0, 0};
+    char *bedfile = NULL, *fnout = "-";
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    htsThreadPool p = {NULL, 0};
+    samFile *in = NULL, *out = NULL, *reject = NULL;
+    clipping_type clipping = soft_clip;
+    cl_param_t param = {1, 0, 0, 0, 0, -1, -1, 0, 0, 1, 5, 0, NULL, NULL, NULL};
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1002},
+        {"soft-clip", no_argument, NULL, 1003},
+        {"hard-clip", no_argument, NULL, 1004},
+        {"strand", no_argument, NULL, 1005},
+        {"clipped", no_argument, NULL, 1006},
+        {"fail", no_argument, NULL, 1007},
+        {"both-ends", no_argument, NULL, 1008},
+        {"filter-len", required_argument, NULL, 1009},
+        {"fail-len", required_argument, NULL, 1010},
+        {"no-excluded", no_argument, NULL, 1011},
+        {"rejects-file", required_argument, NULL, 1012},
+        {"original", no_argument, NULL, 1013},
+        {"keep-tag", no_argument, NULL, 1014},
+        {"tolerance", required_argument, NULL, 1015},
+        {"unmap-len", required_argument, NULL, 1016},
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "b:@:o:O:f:u", lopts, NULL)) >= 0) {
+        switch (c) {
+            case 'b': bedfile = optarg; break;
+            case 'o': fnout = optarg; break;
+            case 'f': param.stats_file = optarg; break;
+            case 'u': wmode[2] = '0'; break;
+            case 1002: param.add_pg = 0; break;
+            case 1003: clipping = soft_clip; break;
+            case 1004: clipping = hard_clip; break;
+            case 1005: param.use_strand = 1; break;
+            case 1006: param.write_clipped = 1; break;
+            case 1007: param.mark_fail = 1; break;
+            case 1008: param.both = 1; break;
+            case 1009: param.filter_len = atoi(optarg); break;
+            case 1010: param.fail_len = atoi(optarg); break;
+            case 1011: param.unmapped = 1; break;
+            case 1012: param.rejects_file = optarg; break;
+            case 1013: param.oa_tag = 1; break;
+            case 1014: param.del_tag = 0; break;
+            case 1015: param.tol = atoi(optarg); break;
+            case 1016: param.unmap_len = atoi(optarg); break;
+            default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+                      /* else fall-through */
+            case '?': usage(); exit(1);
+        }
+    }
+
+    if (!bedfile) {
+        usage();
+        return 1;
+    }
+
+    if (optind + 1 > argc) {
+        usage();
+        return 1;
+    }
+
+    if (param.tol < 0) {
+        fprintf(stderr, "[ampliconclip] warning: invalid tolerance of %d,"
+                        " resetting tolerance to default of 5.\n", param.tol);
+        param.tol = 5;
+    }
+
+    if ((in = sam_open_format(argv[optind], "rb", &ga.in)) == NULL) {
+        print_error_errno("ampliconclip", "cannot open input file");
+        return 1;
+    }
+
+    sam_open_mode(wmode+1, fnout, NULL);
+
+    if ((out = sam_open_format(fnout, wmode, &ga.out)) == NULL) {
+        print_error_errno("ampliconclip", "cannot open output file");
+        return 1;
+    }
+
+    if (param.rejects_file) {
+        sam_open_mode(wmode+1, param.rejects_file, NULL);
+
+        if ((reject = sam_open_format(param.rejects_file, wmode, &ga.out)) == NULL) {
+            print_error_errno("ampliconclip", "cannot open rejects file");
+            return 1;
+        }
+    }
+
+    if (ga.nthreads > 0) {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            fprintf(stderr, "[ampliconclip] error: cannot create thread pool.\n");
+            return 1;
+        }
+        hts_set_opt(in,  HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(out, HTS_OPT_THREAD_POOL, &p);
+
+        if (reject) {
+           hts_set_opt(reject,  HTS_OPT_THREAD_POOL, &p);
+        }
+    }
+
+    param.arg_list = stringify_argv(argc + 1, argv - 1);
+
+    ret = bam_clip(in, out, reject, bedfile, clipping, &param);
+
+    // cleanup
+    sam_close(in);
+
+    if (sam_close(out) < 0) {
+        fprintf(stderr, "[ampliconclip] error: error while closing output file %s.\n", argv[optind+1]);
+        ret = 1;
+    }
+
+    if (reject) {
+        if (sam_close(reject) < 0) {
+            fprintf(stderr, "[ampliconclip] error: error while closing reject file %s.\n", param.rejects_file);
+            ret = 1;
+        }
+    }
+
+    if (p.pool) hts_tpool_destroy(p.pool);
+
+    sam_global_args_free(&ga);
+    free(param.arg_list);
+
+    return ret;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_ampliconclip.c.pysam.c

@@ -0,0 +1,1119 @@
+#include "samtools.pysam.h"
+
+/*  bam_ampliconclip.c -- loads amplicon primers from a BED file and cuts reads
+                          from the 5' end.
+
+    Copyright (C) 2020-2023 Genome Research Ltd.
+
+    Authors: Andrew Whitwham <aw7@sanger.ac.uk>
+             Rob Davies <rmd+git@sanger.ac.uk>
+
+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
+*/
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include <htslib/hts.h>
+#include "htslib/hfile.h"
+#include "htslib/kstring.h"
+#include "htslib/sam.h"
+#include "samtools.h"
+#include "bam_ampliconclip.h"
+
+typedef enum {
+    soft_clip,
+    hard_clip
+} clipping_type;
+
+typedef struct {
+    int add_pg;
+    int use_strand;
+    int write_clipped;
+    int mark_fail;
+    int both;
+    int fail_len;
+    int filter_len;
+    int unmapped;
+    int oa_tag;
+    int del_tag;
+    int tol;
+    int unmap_len;
+    char *arg_list;
+    char *stats_file;
+    char *rejects_file;
+} cl_param_t;
+
+
+static int bed_entry_sort(const void *av, const void *bv) {
+    bed_entry_t *a = (bed_entry_t *) av;
+    bed_entry_t *b = (bed_entry_t *) bv;
+    return a->right < b->right ? -1 : (a->right == b->right ? 0 : 1);
+}
+
+
+int load_bed_file_multi_ref(char *infile, int get_strand, int sort_by_pos, khash_t(bed_list_hash) *bed_lists) {
+    hFILE *fp;
+    int line_count = 0, ret;
+    int64_t left, right;
+    kstring_t line = KS_INITIALIZE;
+    bed_entry_list_t *list;
+    khiter_t bed_itr;
+
+    if ((fp = hopen(infile, "r")) == NULL) {
+        print_error_errno("amplicon", "unable to open file %s.", infile);
+        return 1;
+    }
+
+    char ref[1024];
+
+    while (line.l = 0, kgetline(&line, (kgets_func *)hgets, fp) >= 0) {
+        line_count++;
+        int hret;
+        char strand;
+
+        if (line.l == 0 || *line.s == '#') continue;
+        if (strncmp(line.s, "track ", 6) == 0) continue;
+        if (strncmp(line.s, "browser ", 8) == 0) continue;
+
+        if (get_strand) {
+            if (sscanf(line.s, "%1023s %"SCNd64" %"SCNd64" %*s %*s %c",
+                       ref, &left, &right, &strand) != 4) {
+                fprintf(samtools_stderr, "[amplicon] error: bad bed file format in line %d of %s.\n"
+                                "(N.B. ref/chrom name limited to 1023 characters.)\n",
+                                    line_count, infile);
+                ret = 1;
+                goto error;
+            }
+        } else {
+            if (sscanf(line.s, "%1023s %"SCNd64" %"SCNd64,
+                       ref, &left, &right) != 3) {
+                fprintf(samtools_stderr, "[amplicon] error: bad bed file format in line %d of %s\n"
+                                "(N.B. ref/chrom name limited to 1023 characters.)\n",
+                                    line_count, infile);
+                ret = 1;
+                goto error;
+            }
+        }
+
+        bed_itr = kh_get(bed_list_hash, bed_lists, ref);
+
+        if (bed_itr == kh_end(bed_lists)) { // new ref entry
+            char *ref_name = strdup(ref); // need a copy for the hash key
+
+            if (!ref_name) {
+                fprintf(samtools_stderr, "[amplicon] error: unable to allocate memory for ref name.\n");
+                ret = 1;
+                goto error;
+            }
+
+            bed_itr = kh_put(bed_list_hash, bed_lists, ref_name, &hret);
+
+            if (hret > 0) {
+                list = &kh_val(bed_lists, bed_itr);
+
+                // initialise the new hash entry
+                list->longest = 0;
+                list->size = 0;
+                list->length = 0;
+                list->bp = NULL;
+            } else {
+                fprintf(samtools_stderr, "[amplicon] error: ref hashing failure.\n");
+                ret = 1;
+                goto error;
+            }
+        } else { // existing ref
+            list = &kh_val(bed_lists, bed_itr);
+        }
+
+        if (list->length == list->size) {
+           bed_entry_t *tmp;
+
+           list->size += list->size / 2 + 256;
+
+           if ((tmp = realloc(list->bp, list->size * sizeof(bed_entry_t))) == NULL) {
+               fprintf(samtools_stderr, "[amplicon] error: unable to allocate more memory for bed data.\n");
+               ret = 1;
+               goto error;
+           }
+
+           list->bp = tmp;
+        }
+
+        list->bp[list->length].left  = left;
+        list->bp[list->length].right = right;
+
+        if (get_strand) {
+            if (strand == '+') {
+                list->bp[list->length].rev = 0;
+            } else if (strand == '-') {
+                list->bp[list->length].rev = 1;
+            } else {
+                fprintf(samtools_stderr, "[amplicon] error: bad strand value in line %d, expecting '+' or '-', found '%c'.\n",
+                            line_count, strand);
+                ret = 1;
+                goto error;
+            }
+        }
+
+        if (right - left > list->longest)
+            list->longest = right - left;
+
+        list->length++;
+    }
+
+    if (sort_by_pos) {
+        for (bed_itr = kh_begin(bed_lists); bed_itr != kh_end(bed_lists); ++bed_itr) {
+            if (kh_exist(bed_lists, bed_itr)) {
+                list = &kh_val(bed_lists, bed_itr);
+                qsort(list->bp, list->length, sizeof(list->bp[0]), bed_entry_sort);
+            }
+        }
+    }
+
+    if (kh_size(bed_lists) > 0) {// any entries
+        ret = 0;
+    } else {
+        ret = 1;
+    }
+
+error:
+    ks_free(&line);
+
+    if (hclose(fp) != 0) {
+        fprintf(samtools_stderr, "[amplicon] warning: failed to close %s", infile);
+    }
+
+    return ret;
+}
+
+
+void destroy_bed_hash(khash_t(bed_list_hash) *hash) {
+    khiter_t itr;
+
+    for (itr = kh_begin(hash); itr != kh_end(hash); ++itr) {
+       if (kh_exist(hash, itr)) {
+           free(kh_val(hash, itr).bp);
+           free((char *)kh_key(hash, itr));
+           kh_key(hash, itr) = NULL;
+        }
+    }
+
+    kh_destroy(bed_list_hash, hash);
+}
+
+
+static int matching_clip_site(bed_entry_list_t *sites, hts_pos_t pos,
+                              int is_rev, int use_strand, int64_t longest,
+                              cl_param_t *param) {
+    int i, size;  // may need this to be variable
+    int tol = param->tol;
+    int l = 0, mid = sites->length / 2, r = sites->length;
+    int pos_tol = is_rev ? (pos > tol ? pos - tol : 0) : pos;
+
+    while (r - l > 1) {
+        if (sites->bp[mid].right <= pos_tol) {
+            l = mid;
+        } else {
+            r = mid;
+        }
+        mid = (l + r) / 2;
+    }
+
+    size = 0;
+
+    for (i = l; i < sites->length; i++) {
+        hts_pos_t mod_left, mod_right;
+
+        if (use_strand && is_rev != sites->bp[i].rev)
+            continue;
+
+        if (is_rev) {
+            mod_left = sites->bp[i].left;
+            mod_right = sites->bp[i].right + tol;
+        } else {
+            if (sites->bp[i].left > tol) {
+                mod_left = sites->bp[i].left - tol;
+            } else {
+                mod_left = 0;
+            }
+            mod_right = sites->bp[i].right;
+        }
+
+        if (pos + longest + tol < mod_right)
+            break;
+
+        if (pos >= mod_left && pos <= mod_right) {
+            if (is_rev) {
+                if (size < pos - sites->bp[i].left) {
+                    size = pos - sites->bp[i].left;
+                }
+            } else {
+                if (size < sites->bp[i].right - pos) {
+                    size = sites->bp[i].right - pos;
+                }
+            }
+        }
+    }
+
+    return size;
+}
+
+
+static int bam_trim_left(bam1_t *rec, bam1_t *rec_out, uint32_t bases,
+                         clipping_type clipping) {
+    uint32_t *orig_cigar = bam_get_cigar(rec);
+    uint8_t *orig_seq = bam_get_seq(rec);
+    uint8_t *orig_qual = bam_get_qual(rec);
+    uint8_t *orig_aux = bam_get_aux(rec);
+    uint32_t *new_cigar;
+    uint8_t *new_qual;
+    size_t orig_l_aux = bam_get_l_aux(rec);
+    uint32_t i, j;
+    uint32_t ref_remove = bases, qry_removed = 0, hardclip = 0;
+    hts_pos_t new_pos = rec->core.pos;
+    uint32_t cig_type, cig_op;
+
+    if (rec->l_data + 8 > rec_out->m_data) {
+        uint8_t *new_data = realloc(rec_out->data, rec->l_data + 8);
+        if (!new_data) {
+            fprintf(samtools_stderr, "[ampliconclip] error: could not allocate memoy for new bam record\n");
+            return 1;
+        }
+        rec_out->data = new_data;
+        rec_out->m_data = rec->l_data + 8;
+    }
+
+    // Copy core data & name
+    memcpy(&rec_out->core, &rec->core, sizeof(rec->core));
+    memcpy(rec_out->data, rec->data, rec->core.l_qname);
+
+    // Modify CIGAR
+    new_cigar = bam_get_cigar(rec_out);
+
+    for (i = 0;  i < rec->core.n_cigar; i++) {
+        cig_op = bam_cigar_op(orig_cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if (cig_op == BAM_CHARD_CLIP) {
+            hardclip += bam_cigar_oplen(orig_cigar[i]);
+        } else {
+            if (cig_type & 2) {
+                if (bam_cigar_oplen(orig_cigar[i]) <= ref_remove) {
+                    ref_remove -= bam_cigar_oplen(orig_cigar[i]);
+                } else {
+                    break;
+                }
+                new_pos += bam_cigar_oplen(orig_cigar[i]);
+            }
+            if (cig_type & 1) {
+                qry_removed += bam_cigar_oplen(orig_cigar[i]);
+            }
+        }
+    }
+
+    if (i < rec->core.n_cigar) {
+        cig_type = bam_cigar_type(bam_cigar_op(orig_cigar[i]));
+
+        // account for the last operation
+        if (cig_type & 2) {
+            new_pos += ref_remove;
+        }
+        if (cig_type & 1) {
+            qry_removed += ref_remove;
+        }
+    } else {
+        if (clipping == hard_clip) {
+
+            rec_out->core.l_qseq = 0;
+            rec_out->core.n_cigar = 0;
+
+            if (orig_l_aux)
+                memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+            rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+            return 0;
+        }
+
+        qry_removed = rec->core.l_qseq;
+    }
+
+    j = 0;
+    if (clipping == hard_clip && hardclip + qry_removed > 0) {
+        new_cigar[j++] = bam_cigar_gen(hardclip + qry_removed, BAM_CHARD_CLIP);
+    }
+    if (clipping == soft_clip) {
+        if (hardclip > 0) {
+            new_cigar[j++] = bam_cigar_gen(hardclip, BAM_CHARD_CLIP);
+        }
+        if (qry_removed > 0) {
+            new_cigar[j++] = bam_cigar_gen(qry_removed, BAM_CSOFT_CLIP);
+        }
+    }
+
+    if (i < rec->core.n_cigar
+        && bam_cigar_oplen(orig_cigar[i]) > ref_remove) {
+        new_cigar[j++] = bam_cigar_gen(bam_cigar_oplen(orig_cigar[i]) - ref_remove, bam_cigar_op(orig_cigar[i]));
+
+        // fill in the rest of the cigar
+        i++;
+
+        for (; i < rec->core.n_cigar; i++) {
+            new_cigar[j++] = orig_cigar[i];
+        }
+    }
+
+    rec_out->core.n_cigar = j;
+
+    if (clipping == soft_clip) {
+        qry_removed = 0; // Copy all the sequence and confidence values
+    }
+
+    new_qual = bam_get_seq(rec_out) + (rec->core.l_qseq - qry_removed + 1) / 2;
+    // Copy remaining SEQ
+    if ((qry_removed & 1) == 0) {
+        memcpy(bam_get_seq(rec_out), orig_seq + (qry_removed / 2),
+                (rec->core.l_qseq - qry_removed + 1) / 2); // +1 to account for odd numbers
+    } else {
+        uint8_t *in = orig_seq + qry_removed / 2;
+        uint8_t *out = bam_get_seq(rec_out);
+        uint32_t i;
+        for (i = qry_removed; i < rec->core.l_qseq - 1; i += 2) {
+            *out++ = ((in[0] & 0x0f) << 4) | ((in[1] & 0xf0) >> 4);
+            in++;
+        }
+        if (i < rec->core.l_qseq) {
+            *out++ = (in[0] & 0x0f) << 4;
+        }
+        assert(out == new_qual);
+    }
+
+    // Copy remaining QUAL
+    memmove(new_qual, orig_qual, rec->core.l_qseq - qry_removed);
+
+    // Set new l_qseq
+    rec_out->core.l_qseq -= qry_removed;
+
+    // Move AUX
+    if (orig_l_aux)
+        memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+    // Set new l_data
+    rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+    // put in new pos
+    rec_out->core.pos = new_pos;
+
+    return 0;
+}
+
+
+static int bam_trim_right(bam1_t *rec, bam1_t *rec_out, uint32_t bases,
+                          clipping_type clipping) {
+    uint32_t *orig_cigar = bam_get_cigar(rec);
+    uint8_t *orig_seq = bam_get_seq(rec);
+    uint8_t *orig_qual = bam_get_qual(rec);
+    uint8_t *orig_aux = bam_get_aux(rec);
+    uint32_t *new_cigar;
+    uint32_t new_n_cigar = 0;
+    uint8_t *new_qual;
+    size_t orig_l_aux = bam_get_l_aux(rec);
+    int32_t i;
+    int32_t j;
+    uint32_t ref_remove = bases, qry_removed = 0, hardclip = 0;
+    uint32_t cig_type, cig_op;
+
+    if (rec->l_data + 8 > rec_out->m_data) {
+        uint8_t *new_data = realloc(rec_out->data, rec->l_data + 8);
+        if (!new_data) {
+            fprintf(samtools_stderr, "[ampliconclip] error: could not allocate memoy for new bam record\n");
+            return 1;
+        }
+        rec_out->data = new_data;
+        rec_out->m_data = rec->l_data + 8;
+    }
+
+    // Copy core data & name
+    memcpy(&rec_out->core, &rec->core, sizeof(rec->core));
+    memcpy(rec_out->data, rec->data, rec->core.l_qname);
+
+    // Modify CIGAR here
+    new_cigar = bam_get_cigar(rec_out);
+
+    for (i = rec->core.n_cigar - 1;  i >= 0; --i) {
+        cig_op = bam_cigar_op(orig_cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if (cig_op == BAM_CHARD_CLIP) {
+            hardclip += bam_cigar_oplen(orig_cigar[i]);
+        } else {
+            if (cig_type & 2) {
+                if (bam_cigar_oplen(orig_cigar[i]) <= ref_remove) {
+                    ref_remove -= bam_cigar_oplen(orig_cigar[i]);
+                } else {
+                    break;
+                }
+            }
+            if (cig_type & 1) {
+                qry_removed += bam_cigar_oplen(orig_cigar[i]);
+            }
+        }
+    }
+
+    if (i >= 0) {
+        cig_type = bam_cigar_type(bam_cigar_op(orig_cigar[i]));
+        if (cig_type & 1) {
+            qry_removed += ref_remove;
+        }
+        j = i;
+        if (qry_removed > 0) j++;
+        if (hardclip > 0 && (clipping == soft_clip || qry_removed == 0)) j++;
+    } else {
+        if (clipping == hard_clip) {
+
+            rec_out->core.l_qseq = 0;
+            rec_out->core.n_cigar = 0;
+
+            if (orig_l_aux)
+                memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+            rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+            return 0;
+        }
+
+        qry_removed = rec->core.l_qseq;
+        j = 0;
+        if (hardclip > 0 && clipping == soft_clip) j++;
+    }
+
+    if (clipping == hard_clip && hardclip + qry_removed > 0) {
+        new_cigar[j] = bam_cigar_gen(hardclip + qry_removed, BAM_CHARD_CLIP);
+        new_n_cigar++;
+    }
+    if (clipping == soft_clip) {
+        if (hardclip > 0) {
+            new_cigar[j] = bam_cigar_gen(hardclip, BAM_CHARD_CLIP);
+            new_n_cigar++;
+            if (qry_removed > 0) --j;
+        }
+        if (qry_removed > 0) {
+            new_cigar[j] = bam_cigar_gen(qry_removed, BAM_CSOFT_CLIP);
+            new_n_cigar++;
+        }
+    }
+
+    if (j > 0) {
+        new_cigar[--j] = bam_cigar_gen(bam_cigar_oplen(orig_cigar[i]) - ref_remove, bam_cigar_op(orig_cigar[i]));
+        new_n_cigar++;
+    }
+
+    // fill in the rest of the cigar
+    while (j > 0) {
+        new_cigar[--j] = orig_cigar[--i];
+        new_n_cigar++;
+    }
+
+    rec_out->core.n_cigar = new_n_cigar;
+
+    if (clipping == soft_clip)
+        qry_removed = 0; // Copy all the sequence and confidence values
+
+    new_qual = bam_get_seq(rec_out) + (rec->core.l_qseq - qry_removed + 1) / 2;
+    // Copy remaining SEQ
+    memcpy(bam_get_seq(rec_out), orig_seq, (rec->core.l_qseq - qry_removed + 1) / 2);
+
+    // Copy remaining QUAL
+    memcpy(new_qual, orig_qual, rec->core.l_qseq - qry_removed);
+
+    // Set new l_qseq
+    rec_out->core.l_qseq -= qry_removed;
+
+    // Copy AUX
+    if (orig_l_aux)
+        memcpy(bam_get_aux(rec_out), orig_aux, orig_l_aux);
+
+    // Set new l_data
+    rec_out->l_data = bam_get_aux(rec_out) - rec_out->data + orig_l_aux;
+
+    return 0;
+}
+
+
+static hts_pos_t active_query_len(bam1_t *b) {
+    uint32_t *cigar = bam_get_cigar(b);
+    uint32_t cig_type, cig_op;
+    hts_pos_t len = 0;
+    int i;
+
+    for (i = 0; i < b->core.n_cigar; i++) {
+        cig_op =  bam_cigar_op(cigar[i]);
+        cig_type = bam_cigar_type(cig_op);
+
+        if ((cig_type & 1) && (cig_op != BAM_CSOFT_CLIP)) {
+            len += bam_cigar_oplen(cigar[i]);
+        }
+    }
+
+    return len;
+}
+
+
+static inline void swap_bams(bam1_t **a, bam1_t **b) {
+    bam1_t *tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+
+// Format OA:Z:(RNAME,POS,strand,CIGAR,MAPQ,NM;
+static inline int tag_original_data(bam1_t *orig, kstring_t *oa_tag) {
+    char strand;
+    uint8_t *nm_tag, *old_oa_tag;
+    uint32_t *cigar;
+    int64_t nm = 0;
+    int i, res = 0;
+
+    ks_clear(oa_tag);
+
+    // if there is an existing OA tag the new one gets appended to it
+    if ((old_oa_tag = bam_aux_get(orig, "OA"))) {
+        res |= ksprintf(oa_tag, "%s", bam_aux2Z(old_oa_tag)) < 0;
+    }
+
+    if (orig->core.flag & BAM_FREVERSE)
+        strand = '-';
+    else
+        strand = '+';
+
+    if ((nm_tag = bam_aux_get(orig, "NM"))) {
+        nm = bam_aux2i(nm_tag);
+    }
+
+    res |= ksprintf(oa_tag, "%s,%"PRIhts_pos",%c,", bam_get_qname(orig), orig->core.pos + 1, strand) < 0;
+
+    for (i = 0, cigar = bam_get_cigar(orig); i < orig->core.n_cigar && res == 0; ++i) {
+        res |= kputw(bam_cigar_oplen(cigar[i]), oa_tag) < 0;
+        res |= kputc(bam_cigar_opchr(cigar[i]), oa_tag) < 0;
+    }
+
+    if (nm_tag) {
+        res |= ksprintf(oa_tag, ",%d,%"PRId64";", orig->core.qual, nm) < 0;
+    } else {
+        res |= ksprintf(oa_tag, "%d,;", orig->core.qual) < 0;
+    }
+
+    return res;
+}
+
+
+static int bam_clip(samFile *in, samFile *out, samFile *reject, char *bedfile,
+                    clipping_type clipping, cl_param_t *param) {
+    int ret = 1, r, file_open = 0;
+
+    bam_hdr_t *header = NULL;
+    bam1_t *b = NULL, *b_tmp = NULL;
+    long f_count = 0, r_count = 0, n_count = 0, l_count = 0, l_exclude = 0, b_count = 0;
+    long filtered = 0, written = 0, failed = 0;
+    kstring_t str = KS_INITIALIZE;
+    kstring_t oat = KS_INITIALIZE;
+    kstring_t seq = KS_INITIALIZE;
+    bed_entry_list_t *sites;
+    FILE *stats_fp = samtools_stderr;
+    khash_t(bed_list_hash) *bed_hash = kh_init(bed_list_hash);
+
+    if (load_bed_file_multi_ref(bedfile, param->use_strand, 1, bed_hash)) {
+        fprintf(samtools_stderr, "[ampliconclip] error: unable to load bed file.\n");
+        goto fail;
+    }
+
+    if ((header = sam_hdr_read(in)) == NULL) {
+        fprintf(samtools_stderr, "[ampliconclip] error: could not read header\n");
+        goto fail;
+    }
+
+    // changing pos can ruin coordinate sort order
+    if (sam_hdr_find_tag_hd(header, "SO", &str) == 0 && str.s && strcmp(str.s, "coordinate") == 0) {
+        const char *new_order = "unknown";
+
+        if (sam_hdr_update_hd(header, "SO", new_order) == -1) {
+            fprintf(samtools_stderr, "[ampliconclip] error: unable to change sort order to 'SO:%s'\n", new_order);
+            goto fail;
+        }
+    }
+
+    ks_free(&str);
+
+    if (param->add_pg && sam_hdr_add_pg(header, "samtools", "VN", samtools_version(),
+                        param->arg_list ? "CL" : NULL,
+                        param->arg_list ? param->arg_list : NULL,
+                        NULL) != 0) {
+        fprintf(samtools_stderr, "[ampliconclip] warning: unable to add @PG line to header.\n");
+    }
+    if (sam_hdr_write(out, header) < 0) {
+        fprintf(samtools_stderr, "[ampliconclip] error: could not write header.\n");
+        goto fail;
+    }
+
+    if (reject) {
+       if (sam_hdr_write(reject, header) < 0) {
+           fprintf(samtools_stderr, "[ampliconclip] error: could not write header to rejects file.\n");
+           goto fail;
+       }
+    }
+
+    b = bam_init1();
+    b_tmp = bam_init1();
+    if (!b || !b_tmp) {
+        fprintf(samtools_stderr, "[ampliconclip] error: out of memory when trying to create record.\n");
+        goto fail;
+    }
+
+    int32_t last_tid = -1;
+    int ref_found = 0;
+
+    while ((r = sam_read1(in, header, b)) >= 0) {
+        hts_pos_t pos;
+        int is_rev;
+        int p_size;
+        int been_clipped  = 0, filter = 0;
+        int exclude = (BAM_FUNMAP | BAM_FQCFAIL);
+        khiter_t itr;
+
+        l_count++;
+
+        if (b->core.tid != last_tid) {
+            const char *ref_name;
+
+            ref_found = 0;
+            last_tid = b->core.tid;
+
+            if ((ref_name = sam_hdr_tid2name(header, b->core.tid)) != NULL) {
+                itr = kh_get(bed_list_hash, bed_hash, ref_name);
+
+                if (itr != kh_end(bed_hash)) {
+                    sites = &kh_val(bed_hash, itr);
+                    ref_found = 1;
+                }
+            }
+        }
+
+        if (!(b->core.flag & exclude) && ref_found) {
+            if (param->oa_tag)
+                if (tag_original_data(b, &oat))
+                    goto fail;
+
+            if (!param->both) {
+                if (bam_is_rev(b)) {
+                    pos = bam_endpos(b);
+                    is_rev = 1;
+                } else {
+                    pos = b->core.pos;
+                    is_rev = 0;
+                }
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (is_rev) {
+                        if (bam_trim_right(b, b_tmp, p_size, clipping) != 0)
+                            goto fail;
+
+                        swap_bams(&b, &b_tmp);
+                        r_count++;
+                    } else {
+                        if (bam_trim_left(b, b_tmp, p_size, clipping) != 0)
+                            goto fail;
+
+                        swap_bams(&b, &b_tmp);
+                        f_count++;
+                    }
+
+                    if (param->oa_tag) {
+                        if (bam_aux_update_str(b, "OA", oat.l + 1, (const char *)oat.s))
+                            goto fail;
+                    }
+
+                    if (param->del_tag) {
+                        uint8_t *tag;
+
+                        if ((tag = bam_aux_get(b, "NM")))
+                            bam_aux_del(b, tag);
+
+                        if ((tag = bam_aux_get(b, "MD")))
+                            bam_aux_del(b, tag);
+                    }
+
+                    been_clipped = 1;
+                } else {
+                    if (param->mark_fail) {
+                        b->core.flag |= BAM_FQCFAIL;
+                    }
+
+                    n_count++;
+                }
+            } else {
+                int left = 0, right = 0;
+
+                // left first
+                pos = b->core.pos;
+                is_rev = 0;
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (bam_trim_left(b, b_tmp, p_size, clipping) != 0)
+                        goto fail;
+
+                    swap_bams(&b, &b_tmp);
+                    f_count++;
+                    left = 1;
+                    been_clipped = 1;
+                }
+
+                // the right
+                pos = bam_endpos(b);
+                is_rev = 1;
+
+                if ((p_size = matching_clip_site(sites, pos, is_rev, param->use_strand, sites->longest, param))) {
+                    if (bam_trim_right(b, b_tmp, p_size, clipping) != 0)
+                        goto fail;
+
+                    swap_bams(&b, &b_tmp);
+                    r_count++;
+                    right = 1;
+                    been_clipped = 1;
+                }
+
+                if (left || right) {
+                    uint8_t *tag;
+
+                    if (param->oa_tag) {
+                        if (bam_aux_update_str(b, "OA", oat.l + 1, (const char *)oat.s))
+                            goto fail;
+                    }
+
+                    if (param->del_tag) {
+                        if ((tag = bam_aux_get(b, "NM")))
+                            bam_aux_del(b, tag);
+
+                        if ((tag = bam_aux_get(b, "MD")))
+                            bam_aux_del(b, tag);
+                    }
+                }
+
+                if (left && right) {
+                    b_count++;
+                } else if (!left && !right) {
+                    if (param->mark_fail) {
+                        b->core.flag |= BAM_FQCFAIL;
+                    }
+
+                    n_count++;
+                }
+            }
+
+            if (param->fail_len >= 0 || param->filter_len >= 0 || param->unmap_len >= 0) {
+                hts_pos_t aql = active_query_len(b);
+
+                if (param->fail_len >= 0 && aql <= param->fail_len) {
+                    b->core.flag |= BAM_FQCFAIL;
+                }
+
+                if (param->filter_len >= 0 && aql <= param->filter_len) {
+                    filter = 1;
+                }
+
+                if (param->unmap_len >= 0 && aql <= param->unmap_len) {
+
+                    if (ks_resize(&seq, b->core.l_qseq) < 0) {
+                        fprintf(samtools_stderr, "[ampliconclip] error: allocate memory for sequence %s\n", bam_get_seq(b));
+                        goto fail;
+                    }
+
+                    ks_clear(&seq);
+                    char *sb = ks_str(&seq);
+                    uint8_t *sequence = bam_get_seq(b);
+                    int i;
+
+                    for (i = 0; i < b->core.l_qseq ; ++i) {
+                        *sb++ = seq_nt16_str[bam_seqi(sequence, i)];
+                    }
+
+                    if (bam_set1(b_tmp, b->core.l_qname - b->core.l_extranul - 1, bam_get_qname(b),
+                                 (b->core.flag | BAM_FUNMAP), b->core.tid, b->core.pos, 0,
+                                 0, NULL, b->core.mtid, b->core.mpos, b->core.isize,
+                                 b->core.l_qseq, seq.s, (const char *)bam_get_qual(b),
+                                 bam_get_l_aux(b)) < 0) {
+                        fprintf(samtools_stderr, "[ampliconclip] error: could not unmap read %s\n", bam_get_seq(b));
+                        goto fail;
+                    }
+
+                    memcpy(bam_get_aux(b_tmp), bam_get_aux(b), bam_get_l_aux(b));
+                    b_tmp->l_data += bam_get_l_aux(b);
+                    swap_bams(&b, &b_tmp);
+                }
+           }
+
+           if (b->core.flag & BAM_FQCFAIL) {
+               failed++;
+           }
+
+           if (param->write_clipped && !been_clipped) {
+               filter = 1;
+           }
+
+        } else {
+            l_exclude++;
+
+            if (param->unmapped) {
+                filter = 1;
+            }
+        }
+
+        if (!filter) {
+            if (sam_write1(out, header, b) < 0) {
+                fprintf(samtools_stderr, "[ampliconclip] error: could not write line %ld.\n", l_count);
+                goto fail;
+            }
+
+            written++;
+        } else {
+            if (reject) {
+                if (sam_write1(reject, header, b) < 0) {
+                    fprintf(samtools_stderr, "[ampliconclip] error: could not write to reject file %s\n",
+                            param->rejects_file);
+                    goto fail;
+                }
+            }
+
+            filtered++;
+        }
+    }
+
+    if (r < -1) {
+        fprintf(samtools_stderr, "[ampliconclip] error: failed to read input.\n");
+        goto fail;
+    }
+
+    if (param->stats_file) {
+        if ((stats_fp = fopen(param->stats_file, "w")) == NULL) {
+            fprintf(samtools_stderr, "[ampliconclip] warning: cannot write stats to %s.\n", param->stats_file);
+        } else {
+            file_open = 1;
+        }
+    }
+
+    fprintf(stats_fp, "COMMAND: %s\n"
+                    "TOTAL READS: %ld\n"
+                    "TOTAL CLIPPED: %ld\n"
+                    "FORWARD CLIPPED: %ld\n"
+                    "REVERSE CLIPPED: %ld\n"
+                    "BOTH CLIPPED: %ld\n"
+                    "NOT CLIPPED: %ld\n"
+                    "EXCLUDED: %ld\n"
+                    "FILTERED: %ld\n"
+                    "FAILED: %ld\n"
+                    "WRITTEN: %ld\n", param->arg_list, l_count, f_count + r_count,
+                                    f_count, r_count, b_count, n_count, l_exclude,
+                                    filtered, failed, written);
+
+    if (file_open) {
+        fclose(stats_fp);
+    }
+
+    ret = 0;
+
+fail:
+    destroy_bed_hash(bed_hash);
+    ks_free(&oat);
+    ks_free(&seq);
+    sam_hdr_destroy(header);
+    bam_destroy1(b);
+    bam_destroy1(b_tmp);
+    return ret;
+}
+
+
+static void usage(void) {
+    fprintf(samtools_stderr, "Usage: samtools ampliconclip -b BED file <input.bam> -o <output.bam>\n\n");
+    fprintf(samtools_stderr, "Option: \n");
+    fprintf(samtools_stderr, " -b  FILE            BED file of regions (eg amplicon primers) to be removed.\n");
+    fprintf(samtools_stderr, " -o  FILE            output file name (default samtools_stdout).\n");
+    fprintf(samtools_stderr, " -f  FILE            write stats to file name (default samtools_stderr)\n");
+    fprintf(samtools_stderr, " -u                  Output uncompressed data\n");
+    fprintf(samtools_stderr, " --soft-clip         soft clip amplicon primers from reads (default)\n");
+    fprintf(samtools_stderr, " --hard-clip         hard clip amplicon primers from reads.\n");
+    fprintf(samtools_stderr, " --both-ends         clip on both 5' and 3' ends.\n");
+    fprintf(samtools_stderr, " --strand            use strand data from BED file to match read direction.\n");
+    fprintf(samtools_stderr, " --clipped           only output clipped reads.\n");
+    fprintf(samtools_stderr, " --fail              mark unclipped, mapped reads as QCFAIL.\n");
+    fprintf(samtools_stderr, " --filter-len INT    do not output reads INT size or shorter.\n");
+    fprintf(samtools_stderr, " --fail-len   INT    mark as QCFAIL reads INT size or shorter.\n");
+    fprintf(samtools_stderr, " --unmap-len  INT    unmap reads INT size or shorter, default 0.\n");
+    fprintf(samtools_stderr, " --no-excluded       do not write excluded reads (unmapped or QCFAIL).\n");
+    fprintf(samtools_stderr, " --rejects-file FILE file to write filtered reads.\n");
+    fprintf(samtools_stderr, " --original          for clipped entries add an OA tag with original data.\n");
+    fprintf(samtools_stderr, " --keep-tag          for clipped entries keep the old NM and MD tags.\n");
+    fprintf(samtools_stderr, " --tolerance         match region within this number of bases, default 5.\n");
+    fprintf(samtools_stderr, " --no-PG             do not add an @PG line.\n");
+    sam_global_opt_help(samtools_stderr, "-.O..@-.");
+    fprintf(samtools_stderr, "\nAbout: Soft clips read alignments where they match BED file defined regions.\n"
+                    "Default clipping is only on the 5' end.\n\n");
+}
+
+
+int amplicon_clip_main(int argc, char **argv) {
+    int c, ret;
+    char wmode[4] = {'w', 'b', 0, 0};
+    char *bedfile = NULL, *fnout = "-";
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    htsThreadPool p = {NULL, 0};
+    samFile *in = NULL, *out = NULL, *reject = NULL;
+    clipping_type clipping = soft_clip;
+    cl_param_t param = {1, 0, 0, 0, 0, -1, -1, 0, 0, 1, 5, 0, NULL, NULL, NULL};
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1002},
+        {"soft-clip", no_argument, NULL, 1003},
+        {"hard-clip", no_argument, NULL, 1004},
+        {"strand", no_argument, NULL, 1005},
+        {"clipped", no_argument, NULL, 1006},
+        {"fail", no_argument, NULL, 1007},
+        {"both-ends", no_argument, NULL, 1008},
+        {"filter-len", required_argument, NULL, 1009},
+        {"fail-len", required_argument, NULL, 1010},
+        {"no-excluded", no_argument, NULL, 1011},
+        {"rejects-file", required_argument, NULL, 1012},
+        {"original", no_argument, NULL, 1013},
+        {"keep-tag", no_argument, NULL, 1014},
+        {"tolerance", required_argument, NULL, 1015},
+        {"unmap-len", required_argument, NULL, 1016},
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "b:@:o:O:f:u", lopts, NULL)) >= 0) {
+        switch (c) {
+            case 'b': bedfile = optarg; break;
+            case 'o': fnout = optarg; break;
+            case 'f': param.stats_file = optarg; break;
+            case 'u': wmode[2] = '0'; break;
+            case 1002: param.add_pg = 0; break;
+            case 1003: clipping = soft_clip; break;
+            case 1004: clipping = hard_clip; break;
+            case 1005: param.use_strand = 1; break;
+            case 1006: param.write_clipped = 1; break;
+            case 1007: param.mark_fail = 1; break;
+            case 1008: param.both = 1; break;
+            case 1009: param.filter_len = atoi(optarg); break;
+            case 1010: param.fail_len = atoi(optarg); break;
+            case 1011: param.unmapped = 1; break;
+            case 1012: param.rejects_file = optarg; break;
+            case 1013: param.oa_tag = 1; break;
+            case 1014: param.del_tag = 0; break;
+            case 1015: param.tol = atoi(optarg); break;
+            case 1016: param.unmap_len = atoi(optarg); break;
+            default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+                      /* else fall-through */
+            case '?': usage(); samtools_exit(1);
+        }
+    }
+
+    if (!bedfile) {
+        usage();
+        return 1;
+    }
+
+    if (optind + 1 > argc) {
+        usage();
+        return 1;
+    }
+
+    if (param.tol < 0) {
+        fprintf(samtools_stderr, "[ampliconclip] warning: invalid tolerance of %d,"
+                        " resetting tolerance to default of 5.\n", param.tol);
+        param.tol = 5;
+    }
+
+    if ((in = sam_open_format(argv[optind], "rb", &ga.in)) == NULL) {
+        print_error_errno("ampliconclip", "cannot open input file");
+        return 1;
+    }
+
+    sam_open_mode(wmode+1, fnout, NULL);
+
+    if ((out = sam_open_format(fnout, wmode, &ga.out)) == NULL) {
+        print_error_errno("ampliconclip", "cannot open output file");
+        return 1;
+    }
+
+    if (param.rejects_file) {
+        sam_open_mode(wmode+1, param.rejects_file, NULL);
+
+        if ((reject = sam_open_format(param.rejects_file, wmode, &ga.out)) == NULL) {
+            print_error_errno("ampliconclip", "cannot open rejects file");
+            return 1;
+        }
+    }
+
+    if (ga.nthreads > 0) {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            fprintf(samtools_stderr, "[ampliconclip] error: cannot create thread pool.\n");
+            return 1;
+        }
+        hts_set_opt(in,  HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(out, HTS_OPT_THREAD_POOL, &p);
+
+        if (reject) {
+           hts_set_opt(reject,  HTS_OPT_THREAD_POOL, &p);
+        }
+    }
+
+    param.arg_list = stringify_argv(argc + 1, argv - 1);
+
+    ret = bam_clip(in, out, reject, bedfile, clipping, &param);
+
+    // cleanup
+    sam_close(in);
+
+    if (sam_close(out) < 0) {
+        fprintf(samtools_stderr, "[ampliconclip] error: error while closing output file %s.\n", argv[optind+1]);
+        ret = 1;
+    }
+
+    if (reject) {
+        if (sam_close(reject) < 0) {
+            fprintf(samtools_stderr, "[ampliconclip] error: error while closing reject file %s.\n", param.rejects_file);
+            ret = 1;
+        }
+    }
+
+    if (p.pool) hts_tpool_destroy(p.pool);
+
+    sam_global_args_free(&ga);
+    free(param.arg_list);
+
+    return ret;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_ampliconclip.h

@@ -0,0 +1,54 @@
+/*  bam_ampliconclip.h -- shared functions between amplicon clip/stats
+
+    Copyright (C) 2020-2021 Genome Research Ltd.
+
+    Author: James Bonfield <jkb@sanger.ac.uk>
+
+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.  */
+
+#ifndef BAM_AMPLICONCLIP_H
+#define BAM_AMPLICONCLIP_H
+
+#include "htslib/khash.h"
+
+typedef struct {
+    int64_t left;
+    int64_t right;
+    int rev;
+} bed_entry_t;
+
+typedef struct {
+    bed_entry_t *bp;
+    int64_t longest;
+    int length;
+    int size;
+} bed_entry_list_t;
+
+KHASH_MAP_INIT_STR(bed_list_hash, bed_entry_list_t);
+
+#define BED_LIST_INIT {NULL, 0, 0, 0, {0}}
+
+
+int load_bed_file_multi_ref(char *infile, int get_strand,
+                        int sort_by_pos, khash_t(bed_list_hash) *bed_lists);
+
+void destroy_bed_hash(khash_t(bed_list_hash) *hash);
+
+
+#endif /* BAM_AMPLICONCLIP_H */

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_aux.c

@@ -0,0 +1,61 @@
+/*  bam_aux.c -- remaining aux field handling.
+
+    Copyright (C) 2008-2010, 2013, 2015, 2019 Genome Research Ltd.
+    Portions copyright (C) 2011 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <ctype.h>
+#include "htslib/sam.h"
+
+static inline int bam_aux_type2size(int x)
+{
+    if (x == 'C' || x == 'c' || x == 'A') return 1;
+    else if (x == 'S' || x == 's') return 2;
+    else if (x == 'I' || x == 'i' || x == 'f' || x == 'F') return 4;
+    else return 0;
+}
+
+#define __skip_tag(s) do { \
+        int type = toupper(*(s)); \
+        ++(s); \
+        if (type == 'Z' || type == 'H') { while (*(s)) ++(s); ++(s); } \
+        else if (type == 'B') (s) += 5 + bam_aux_type2size(*(s)) * (*(int32_t*)((s)+1)); \
+        else (s) += bam_aux_type2size(type); \
+    } while(0)
+
+
+int bam_aux_drop_other(bam1_t *b, uint8_t *s)
+{
+    if (s) {
+        uint8_t *p, *aux;
+        aux = bam_get_aux(b);
+        p = s - 2;
+        __skip_tag(s);
+        memmove(aux, p, s - p);
+        b->l_data -= bam_get_l_aux(b) - (s - p);
+    } else {
+        b->l_data -= bam_get_l_aux(b);
+    }
+    return 0;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_color.c.pysam.c

@@ -0,0 +1,175 @@
+#include "samtools.pysam.h"
+
+/*  bam_color.c -- color-space support.
+
+    Copyright (C) 2009, 2012 University of California - Los Angeles.
+
+    Author: Nils Homer <nilshomer@gmail.com>
+
+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.  */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <string.h>
+
+#include "htslib/sam.h"
+
+/*!
+ @abstract     Get the color encoding the previous and current base
+ @param b      pointer to an alignment
+ @param i      The i-th position, 0-based
+ @return       color
+
+ @discussion   Returns 0 no color information is found.
+ */
+char bam_aux_getCSi(bam1_t *b, int i)
+{
+    uint8_t *c = bam_aux_get(b, "CS");
+    char *cs = NULL;
+
+    // return the base if the tag was not found
+    if(0 == c) return 0;
+
+    cs = bam_aux2Z(c);
+    // adjust for strandedness and leading adaptor
+    if(bam_is_rev(b)) {
+        i = strlen(cs) - 1 - i;
+        // adjust for leading hard clip
+        uint32_t cigar = bam_get_cigar(b)[0];
+        if((cigar & BAM_CIGAR_MASK) == BAM_CHARD_CLIP) {
+        i -= cigar >> BAM_CIGAR_SHIFT;
+        }
+    } else { i++; }
+    return cs[i];
+}
+
+/*!
+ @abstract     Get the color quality of the color encoding the previous and current base
+ @param b      pointer to an alignment
+ @param i      The i-th position, 0-based
+ @return       color quality
+
+ @discussion   Returns 0 no color information is found.
+ */
+char bam_aux_getCQi(bam1_t *b, int i)
+{
+    uint8_t *c = bam_aux_get(b, "CQ");
+    char *cq = NULL;
+
+    // return the base if the tag was not found
+    if(0 == c) return 0;
+
+    cq = bam_aux2Z(c);
+    // adjust for strandedness
+    if(bam_is_rev(b)) {
+        i = strlen(cq) - 1 - i;
+        // adjust for leading hard clip
+        uint32_t cigar = bam_get_cigar(b)[0];
+        if((cigar & BAM_CIGAR_MASK) == BAM_CHARD_CLIP) {
+        i -= (cigar >> BAM_CIGAR_SHIFT);
+        }
+    }
+    return cq[i];
+}
+
+char bam_aux_nt2int(char a)
+{
+    switch(toupper(a)) {
+        case 'A':
+            return 0;
+            break;
+        case 'C':
+            return 1;
+            break;
+        case 'G':
+            return 2;
+            break;
+        case 'T':
+            return 3;
+            break;
+        default:
+            return 4;
+            break;
+    }
+}
+
+char bam_aux_ntnt2cs(char a, char b)
+{
+    a = bam_aux_nt2int(a);
+    b = bam_aux_nt2int(b);
+    if(4 == a || 4 == b) return '4';
+    return "0123"[(int)(a ^ b)];
+}
+
+/*!
+ @abstract     Get the color error profile at the give position
+ @param b      pointer to an alignment
+ @return       the original color if the color was an error, '-' (dash) otherwise
+
+ @discussion   Returns 0 no color information is found.
+ */
+char bam_aux_getCEi(bam1_t *b, int i)
+{
+    int cs_i;
+    uint8_t *c = bam_aux_get(b, "CS");
+    char *cs = NULL;
+    char prev_b, cur_b;
+    char cur_color, cor_color;
+
+    // return the base if the tag was not found
+    if(0 == c) return 0;
+
+    cs = bam_aux2Z(c);
+
+    // adjust for strandedness and leading adaptor
+    if(bam_is_rev(b)) { //reverse strand
+        cs_i = strlen(cs) - 1 - i;
+        // adjust for leading hard clip
+        uint32_t cigar = bam_get_cigar(b)[0];
+        if((cigar & BAM_CIGAR_MASK) == BAM_CHARD_CLIP) {
+            cs_i -= cigar >> BAM_CIGAR_SHIFT;
+        }
+        // get current color
+        cur_color = cs[cs_i];
+        // get previous base.  Note: must rc adaptor
+        prev_b = (cs_i == 1) ? "TGCAN"[(int)bam_aux_nt2int(cs[0])] : seq_nt16_str[bam_seqi(bam_get_seq(b), i+1)];
+        // get current base
+        cur_b = seq_nt16_str[bam_seqi(bam_get_seq(b), i)];
+    }
+    else {
+        cs_i=i+1;
+        // get current color
+        cur_color = cs[cs_i];
+        // get previous base
+        prev_b = (0 == i) ? cs[0] : seq_nt16_str[bam_seqi(bam_get_seq(b), i-1)];
+        // get current base
+        cur_b = seq_nt16_str[bam_seqi(bam_get_seq(b), i)];
+    }
+
+    // corrected color
+    cor_color = bam_aux_ntnt2cs(prev_b, cur_b);
+
+    if(cur_color == cor_color) {
+        return '-';
+    }
+    else {
+        return cur_color;
+    }
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_flags.c

@@ -0,0 +1,86 @@
+/*  bam_flags.c -- flags subcommand.
+
+    Copyright (C) 2013-2014, 2021 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <htslib/sam.h>
+#include "samtools.h"
+
+static void usage(FILE *fp)
+{
+    static const struct { int bit; const char *desc; } *fl, flags[] = {
+        { BAM_FPAIRED, "paired-end / multiple-segment sequencing technology" },
+        { BAM_FPROPER_PAIR, "each segment properly aligned according to aligner" },
+        { BAM_FUNMAP, "segment unmapped" },
+        { BAM_FMUNMAP, "next segment in the template unmapped" },
+        { BAM_FREVERSE, "SEQ is reverse complemented" },
+        { BAM_FMREVERSE, "SEQ of next segment in template is rev.complemented" },
+        { BAM_FREAD1, "the first segment in the template" },
+        { BAM_FREAD2, "the last segment in the template" },
+        { BAM_FSECONDARY, "secondary alignment" },
+        { BAM_FQCFAIL, "not passing quality controls or other filters" },
+        { BAM_FDUP, "PCR or optical duplicate" },
+        { BAM_FSUPPLEMENTARY, "supplementary alignment" },
+        { 0, NULL }
+    };
+
+    fprintf(fp,
+"About: Convert between textual and numeric flag representation\n"
+"Usage: samtools flags FLAGS...\n"
+"\n"
+"Each FLAGS argument is either an INT (in decimal/hexadecimal/octal) representing\n"
+"a combination of the following numeric flag values, or a comma-separated string\n"
+"NAME,...,NAME representing a combination of the following flag names:\n"
+"\n");
+    for (fl = flags; fl->desc; fl++) {
+        char *name = bam_flag2str(fl->bit);
+        fprintf(fp, "%#6x %5d  %-15s%s\n", fl->bit, fl->bit, name, fl->desc);
+        free(name);
+    }
+}
+
+
+int main_flags(int argc, char *argv[])
+{
+    if ( argc < 2 ) { usage(stdout); return 0; }
+
+    int i;
+    for (i = 1; i < argc; i++)
+    {
+        int mask = bam_str2flag(argv[i]);
+        if ( mask<0 ) { print_error("flags", "Could not parse \"%s\"", argv[i]); usage(stderr); return 1; }
+        char *str = bam_flag2str(mask);
+        printf("0x%x\t%d\t%s\n", mask, mask, str);
+        free(str);
+    }
+    return 0;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_flags.c.pysam.c

@@ -0,0 +1,88 @@
+#include "samtools.pysam.h"
+
+/*  bam_flags.c -- flags subcommand.
+
+    Copyright (C) 2013-2014, 2021 Genome Research Ltd.
+
+    Author: Petr Danecek <pd3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <htslib/sam.h>
+#include "samtools.h"
+
+static void usage(FILE *fp)
+{
+    static const struct { int bit; const char *desc; } *fl, flags[] = {
+        { BAM_FPAIRED, "paired-end / multiple-segment sequencing technology" },
+        { BAM_FPROPER_PAIR, "each segment properly aligned according to aligner" },
+        { BAM_FUNMAP, "segment unmapped" },
+        { BAM_FMUNMAP, "next segment in the template unmapped" },
+        { BAM_FREVERSE, "SEQ is reverse complemented" },
+        { BAM_FMREVERSE, "SEQ of next segment in template is rev.complemented" },
+        { BAM_FREAD1, "the first segment in the template" },
+        { BAM_FREAD2, "the last segment in the template" },
+        { BAM_FSECONDARY, "secondary alignment" },
+        { BAM_FQCFAIL, "not passing quality controls or other filters" },
+        { BAM_FDUP, "PCR or optical duplicate" },
+        { BAM_FSUPPLEMENTARY, "supplementary alignment" },
+        { 0, NULL }
+    };
+
+    fprintf(fp,
+"About: Convert between textual and numeric flag representation\n"
+"Usage: samtools flags FLAGS...\n"
+"\n"
+"Each FLAGS argument is either an INT (in decimal/hexadecimal/octal) representing\n"
+"a combination of the following numeric flag values, or a comma-separated string\n"
+"NAME,...,NAME representing a combination of the following flag names:\n"
+"\n");
+    for (fl = flags; fl->desc; fl++) {
+        char *name = bam_flag2str(fl->bit);
+        fprintf(fp, "%#6x %5d  %-15s%s\n", fl->bit, fl->bit, name, fl->desc);
+        free(name);
+    }
+}
+
+
+int main_flags(int argc, char *argv[])
+{
+    if ( argc < 2 ) { usage(samtools_stdout); return 0; }
+
+    int i;
+    for (i = 1; i < argc; i++)
+    {
+        int mask = bam_str2flag(argv[i]);
+        if ( mask<0 ) { print_error("flags", "Could not parse \"%s\"", argv[i]); usage(samtools_stderr); return 1; }
+        char *str = bam_flag2str(mask);
+        fprintf(samtools_stdout, "0x%x\t%d\t%s\n", mask, mask, str);
+        free(str);
+    }
+    return 0;
+}
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_import.c.pysam.c

@@ -0,0 +1,525 @@
+#include "samtools.pysam.h"
+
+/* bam_import -- Import of FASTQ files.
+ *
+ *   samtools import -1 a_1.fq -2 a_2.fq --i1 a_i1.fq --i2 a_i2.fq
+ *   samtools import a_1.fq a_2.fq
+ *   samtools import a_interleaved.fq
+ *
+ * Copyright (C) 2020-2021, 2023 Genome Research Ltd.
+ *
+ * Author: James Bonfield <jkb@sanger.ac.uk>
+ */
+
+/*
+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 notices 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.
+*/
+
+// TODO: Store other non-aux comments; in new sam tag?
+
+#include <config.h>
+#include <ctype.h>
+
+#include "htslib/sam.h"
+#include "htslib/thread_pool.h"
+
+#include "samtools.h"
+#include "sam_opts.h"
+
+static int usage(FILE *fp, int exit_status) {
+    fprintf(fp, "Usage: samtools import [options] [file.fastq ...]\n");
+    fprintf(fp, "\n");
+    fprintf(fp, "Options:\n");
+    fprintf(fp, "  -s FILE      Read paired-ended data from single FILE\n");
+    fprintf(fp, "  -0 FILE      Read single-ended data from FILE\n");
+    fprintf(fp, "  -1 FILE      Read-1 from FILE\n");
+    fprintf(fp, "  -2 FILE      Read-2 from FILE\n");
+    fprintf(fp, "  --i1 FILE    Index-1 from FILE\n");
+    fprintf(fp, "  --i2 FILE    Index-2 from FILE\n");
+    fprintf(fp, "  -i           Parse CASAVA identifier\n");
+    fprintf(fp, "  --barcode-tag TAG\n");
+    fprintf(fp, "               Tag to use with barcode sequences [BC]\n");
+    fprintf(fp, "  --quality-tag TAG\n");
+    fprintf(fp, "               Tag to use with barcode qualities [QT]\n");
+    fprintf(fp, "  -N, --name2  Use 2nd field as read name (SRA format)\n");
+    fprintf(fp, "  -r STRING    Build up a complete @RG line\n");
+    fprintf(fp, "  -R STRING    Add a simple RG line of \"@RG\\tID:STRING\"\n");
+    fprintf(fp, "  -T TAGLIST   Parse tags in SAM format; list of '*' for all\n");
+    fprintf(fp, "  -o FILE      Output to FILE instead of samtools_stdout\n");
+    fprintf(fp, "  -u           Uncompressed output\n");
+    fprintf(fp, "  --order TAG  Store Nth record count in TAG\n");
+    fprintf(fp, "\n");
+    sam_global_opt_help(fp, "-.O.-@--");
+
+    fprintf(fp, "\nA single fastq file will be interpreted as -s, -0 or -1 depending on\n");
+    fprintf(fp, "file contents, and a pair of fastq files as \"-1 FILE1 -2 FILE2\".\n");
+
+    return exit_status;
+}
+
+// Order matters here as we want to read index elements before main
+// sequences so on reading the seqs we can emit a fully annotated record.
+enum fileno {
+    FQ_I1, FQ_I2, // index seqs for R1 and R2
+    FQ_R0,        // single file and unpaired data (singled-ended tech).
+    FQ_R1, FQ_R2, // separate read1 and read2 files
+    FQ_SINGLE,    // single file, but with read1 and/or read2 present.
+    FQ_END
+};
+
+typedef struct {
+    sam_global_args ga;
+    int no_pg;
+    char *fn[FQ_END], *fn_out;
+    int idx_both;      // add index to READ2 too, not just READ1
+    int casava;
+    char *barcode_seq;
+    char *barcode_qual;
+    char *aux;
+    char *rg;
+    char *rg_line;
+    char *order;
+    int order_str;
+    int compress_level;
+    htsThreadPool p;
+    int name2;
+} opts_t;
+
+// Append a sequence and quality string from a BAM record to a BC:Z and
+// QT:Z style aux tag string.
+static int append_index(kstring_t *s, kstring_t *q, bam1_t *b) {
+    char *sp, *qp;
+    if (ks_resize(s, s->l + b->core.l_qseq+1 +1) < 0)
+        return -1;
+    if (ks_resize(q, q->l + b->core.l_qseq+1 +1) < 0)
+        return -1;
+
+    sp = s->s + s->l - (s->l > 0);
+    qp = q->s + q->l - (q->l > 0);
+
+    if (s->l)
+        *sp++ = '-';
+
+    if (q->l)
+        *qp++ = ' ';
+
+    int i;
+    uint8_t *seq = bam_get_seq(b);
+    uint8_t *qual = bam_get_qual(b);
+    for (i = 0; i < b->core.l_qseq; i++) {
+        *sp++ = seq_nt16_str[bam_seqi(seq, i)];
+        *qp++ = qual[i] + '!';
+    }
+    *sp++ = 0;
+    *qp++ = 0;
+
+    s->l = sp - s->s;
+    q->l = qp - q->s;
+
+    return 0;
+}
+
+static int import_fastq(int argc, char **argv, opts_t *opts) {
+    int i, n, ret = 0;
+    samFile *fp_in[FQ_END] = {NULL};
+    bam1_t *b = bam_init1();
+    int ids[FQ_END];
+    samFile *fp_out = NULL;
+    sam_hdr_t *hdr_out = NULL;
+    kstring_t index_str = {0,0};
+    kstring_t read_str = {0,0};
+    char *rg = opts->rg;
+    kstring_t rg_line = {0,0};
+    uint64_t read_num = 0;
+    kstring_t idx_seq  = {0};
+    kstring_t idx_qual = {0};
+
+    // Any additional arguments are assumed to be r1 r2, as a
+    // short cut. We support reading index tags out of those too (eg
+    // Illumina CASAVA format), but if we do that we lack the barcode
+    // quality string.
+    //
+    // We also consider a read name ending in /1 or /2 to be a single
+    // file containing interleaved fastq records for both ends.
+    // These will be labeled as fn[FQ_R1] but adjusted during reading.
+    if (argc == 1)
+        opts->fn[FQ_SINGLE] = argv[0];
+    else
+        for (i = 0; i < 4; i++)
+            if (argc > i)
+                opts->fn[FQ_R1+i] = argv[i];
+
+    // Open all files
+    for (i = n = 0; i < FQ_END; i++) {
+        if (!opts->fn[i])
+            continue;
+        fp_in[i] = sam_open_format(opts->fn[i], "r", &opts->ga.in);
+        if (!fp_in[i]) {
+            perror(opts->fn[i]);
+            ret = -1;
+            goto err;
+        }
+        if (opts->p.pool)
+            hts_set_thread_pool(fp_in[i], &opts->p);
+        ids[n++] = i;
+
+        if (opts->name2)
+            hts_set_opt(fp_in[i], FASTQ_OPT_NAME2, 1);
+        if (opts->casava)
+            hts_set_opt(fp_in[i], FASTQ_OPT_CASAVA, 1);
+        if (opts->barcode_seq) // for auto-CASAVA parsing
+            hts_set_opt(fp_in[i], FASTQ_OPT_BARCODE, opts->barcode_seq);
+        if (opts->aux)
+            hts_set_opt(fp_in[i], FASTQ_OPT_AUX,
+                        *opts->aux == '*' || *opts->aux == '\0'
+                        ? NULL : opts->aux);
+
+        switch (i) {
+        case FQ_I1:
+            kputs("--i1 I1.fastq ", &read_str);
+            kputs("i*", &index_str);
+            break;
+        case FQ_I2:
+            kputs("--i2 I2.fastq ", &read_str);
+            kputs("i*", &index_str);
+            break;
+
+        case FQ_R0:
+            kputs("-0 unpaired.fastq ", &read_str);
+            break;
+
+        case FQ_R1:
+            kputs("-1 R1.fastq ", &read_str);
+            break;
+
+        case FQ_R2:
+            kputs("-2 R2.fastq ", &read_str);
+            break;
+
+        case FQ_SINGLE:
+            kputs("-N -o paired.fastq ", &read_str);
+            break;
+
+        default:
+            ks_clear(&read_str); // not reversible
+            kputs("", &read_str);
+        }
+    }
+    if (n == 0) {
+        bam_destroy1(b);
+        return usage(samtools_stdout, EXIT_SUCCESS);
+    }
+
+    char out_mode[10] = {'w', 0, 0};
+    if (opts->compress_level != -1)
+        out_mode[1] = '0' + opts->compress_level;
+    sam_open_mode(out_mode+strlen(out_mode), opts->fn_out, NULL);
+    fp_out = sam_open_format(opts->fn_out, out_mode, &opts->ga.out);
+    if (!fp_out) {
+        perror(opts->fn_out);
+        goto err;
+    }
+    autoflush_if_stdout(fp_out, opts->fn_out);
+    if (opts->p.pool)
+        hts_set_thread_pool(fp_out, &opts->p);
+
+    // Create header
+    if (ks_len(&read_str)) {
+        char CO[2100];
+        if (ks_len(&index_str))
+            snprintf(CO, sizeof(CO), "@CO\tReverse with: samtools fastq %s "
+                    "--index-format=\"%s\"\n",
+                    ks_str(&read_str), ks_str(&index_str));
+        else
+            snprintf(CO, sizeof(CO), "@CO\tReverse with: samtools fastq %s\n",
+                    ks_str(&read_str));
+
+        hdr_out = sam_hdr_parse(strlen(CO), CO);
+    } else {
+        hdr_out = sam_hdr_init();
+    }
+
+    // Add a version line with the sort order to the output header
+    if (sam_hdr_add_line(hdr_out, "HD", "VN", SAM_FORMAT_VERSION, "SO", "unsorted", "GO", "query", NULL) < 0) {
+        fprintf(samtools_stderr, "Could not set SO and GO in the header.\n");
+        goto err;
+    }
+
+    // Read group
+    if (opts->rg_line) {
+        if (*opts->rg_line != '@')
+            ksprintf(&rg_line, "@RG\t%s", opts->rg_line);
+        else
+            kputs(opts->rg_line, &rg_line);
+    } else if (opts->rg) {
+        ksprintf(&rg_line, "@RG\tID:%s", opts->rg);
+    }
+
+    if (ks_len(&rg_line)) {
+        if (sam_hdr_add_lines(hdr_out, ks_str(&rg_line), 0) < 0)
+            goto err;
+        rg = strstr(ks_str(&rg_line), "\tID:");
+        if (!rg) {
+            fprintf(samtools_stderr, "\"-r RG-LINE\" option contained no ID field\n");
+            goto err;
+        }
+        rg += 4;
+
+        i = 0;
+        while (rg[i] != '\t' && rg[i] != '\0')
+            i++;
+        rg[i] = 0;
+    }
+
+    if ((ret = sam_hdr_write(fp_out, hdr_out)) < 0)
+        goto err;
+
+
+    // Interleave / combine from n files (ids[0..n-1]).
+    int res;
+    int eof = 0;
+    do {
+        idx_seq.l = idx_qual.l = 0;
+        for (i = 0; i < n; i++) {
+            if ((res = sam_read1(fp_in[ids[i]], NULL, b)) < 0) {
+                if (res == -1) {
+                    eof++;
+                    continue;
+                } else
+                    break;
+            }
+
+            // index
+            if (ids[i] == FQ_I1 || ids[i] == FQ_I2) {
+                if (append_index(&idx_seq, &idx_qual, b) < 0) {
+                    res = -1;
+                    break;
+                }
+                continue;
+            }
+
+            // full read
+            if (idx_seq.l) {
+                if (opts->idx_both || ids[i] == FQ_SINGLE ||
+                    ids[i] == FQ_R0 || ids[i] == FQ_R1) {
+                    if (bam_aux_append(b, opts->barcode_seq, 'Z', idx_seq.l,
+                                       (uint8_t *)idx_seq.s) ||
+                        bam_aux_append(b, opts->barcode_qual, 'Z', idx_qual.l,
+                                       (uint8_t *)idx_qual.s)) {
+                        res = -1;
+                        break;
+                    }
+                }
+            }
+
+            switch(ids[i]) {
+            case FQ_R0:
+                // unpaired; no flags to declare
+                break;
+            case FQ_SINGLE:
+                // paired (but don't know if R1 or R2) or unpaired.
+                // We rely on the /1 and /2 read suffix parsing in htslib
+                // to distinguish the two cases, or CASAVA tags if
+                // explicitly enabled.
+                break;
+            case FQ_R1:
+                if ((b->core.flag & (BAM_FREAD1 | BAM_FREAD2)) == 0)
+                    b->core.flag |= BAM_FREAD1;
+                b->core.flag |= BAM_FPAIRED;
+                if (i+1 < n && ids[i+1] == FQ_R2)
+                    b->core.flag |= BAM_FMUNMAP;
+                break;
+            case FQ_R2:
+                b->core.flag |= BAM_FPAIRED | BAM_FREAD2;
+                if (i > 0 && ids[i-1] == FQ_R1)
+                    b->core.flag |= BAM_FMUNMAP;
+                break;
+            }
+
+            if (rg) {
+                if (bam_aux_append(b, "RG", 'Z', strlen(rg)+1,
+                                   (uint8_t *)rg) < 0) {
+                    ret = -1;
+                    goto err;
+                }
+            }
+
+            if (opts->order) {
+                if (opts->order_str) {
+                    char buf[25];
+                    snprintf(buf, sizeof(buf), "%0*"PRIu64,
+                             opts->order_str, read_num++);
+                    if (bam_aux_update_str(b, opts->order,
+                                           strlen(buf), buf) < 0) {
+                        ret = -1;
+                        goto err;
+                    }
+                } else {
+                    if (bam_aux_update_int(b, opts->order, read_num++) < 0) {
+                        ret = -1;
+                        goto err;
+                    }
+                    if (read_num == UINT_MAX)
+                        fprintf(samtools_stderr, "Warning: --order tag has overflowed."
+                                "  Consider using TAG:LENGTH instead\n");
+                }
+            }
+
+            res = sam_write1(fp_out, hdr_out, b);
+        }
+    } while (res >= 0);
+
+    if (res != -1) {
+        print_error("import", "truncated file. Aborting");
+        ret = res;
+        goto err;
+    }
+
+    if (eof != n) {
+        print_error("import", "input files with differing number of records");
+        ret = -1;
+        goto err;
+    }
+
+    // Close and return
+    ret = 0;
+err:
+    bam_destroy1(b);
+    sam_hdr_destroy(hdr_out);
+    ks_free(&rg_line);
+    ks_free(&index_str);
+    ks_free(&read_str);
+    if (fp_out) {
+        release_autoflush(fp_out);
+        if (sam_close(fp_out) < 0) {
+            perror(opts->fn_out);
+            ret |= -1;
+        }
+    }
+    for (i = 0; i < FQ_END; i++) {
+        if (fp_in[i] && sam_close(fp_in[i]) < 0) {
+            perror(opts->fn[i]);
+            ret |= -1;
+        }
+    }
+    ks_free(&idx_seq);
+    ks_free(&idx_qual);
+
+    return ret;
+}
+
+int main_import(int argc, char *argv[]) {
+    int c;
+    opts_t opts = {
+        .no_pg = 0,
+        .ga = SAM_GLOBAL_ARGS_INIT,
+        .fn = {NULL},
+        .fn_out = "-",
+        .casava = 0,
+        .barcode_seq = "BC",
+        .barcode_qual = "QT",
+        .aux = NULL,
+        .rg = NULL,
+        .rg_line = NULL,
+        .order = NULL,
+        .order_str = 0,
+        .compress_level = -1,
+        .name2 = 0,
+    };
+    kstring_t rg = {0};
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, '-', '@'),
+        {"no-PG", no_argument, NULL, 9},
+        {"i1", required_argument, NULL, 1},
+        {"i2", required_argument, NULL, 2},
+        {"r1", required_argument, NULL, '1'},
+        {"r2", required_argument, NULL, '2'},
+        {"rg", required_argument, NULL, 'R'},
+        {"rg-line", required_argument, NULL, 'r'},
+        {"order", required_argument, NULL, 3},
+        {"barcode-tag", required_argument, NULL, 4},
+        {"quality-tag", required_argument, NULL, 5},
+        {"name2", no_argument, NULL, 'N'},
+        { NULL, 0, NULL, 0 }
+    };
+
+    while ((c = getopt_long(argc, argv, "1:2:s:0:bhiT:r:R:o:O:u@:N", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'b': opts.idx_both = 1; break;
+        case '0': opts.fn[FQ_R0] = optarg; break;
+        case '1': opts.fn[FQ_R1] = optarg; break;
+        case '2': opts.fn[FQ_R2] = optarg; break;
+        case  1:  opts.fn[FQ_I1] = optarg; break;
+        case  2:  opts.fn[FQ_I2] = optarg; break;
+        case 's': opts.fn[FQ_SINGLE] = optarg; break;
+        case 'o': opts.fn_out = optarg; break;
+        case 'i': opts.casava = 1; break;
+        case  4:  opts.barcode_seq = optarg; break;
+        case  5:  opts.barcode_qual = optarg; break;
+        case 'T': opts.aux = optarg; break;
+        case 'u': opts.compress_level = 0; break;
+        case 'R': opts.rg = optarg; break;
+        case 'r':
+            if (*optarg != '@' && ks_len(&rg) == 0)
+                kputs("@RG", &rg);
+            if (ks_len(&rg))
+                kputc_('\t', &rg);
+            kputs(optarg, &rg);
+            opts.rg_line = rg.s;
+            break;
+
+        case 'N': opts.name2 = 1; break;
+
+        case 9: opts.no_pg = 1; break;
+        case 3:
+            opts.order = optarg;
+            if (strlen(optarg) > 3 && optarg[2] == ':')
+                opts.order_str = atoi(optarg+3);
+            break;
+
+        case 'h': return usage(samtools_stdout, EXIT_SUCCESS);
+        case '?': return usage(samtools_stderr, EXIT_FAILURE);
+
+        default:
+            if (parse_sam_global_opt(c, optarg, lopts, &opts.ga) != 0)
+                return usage(samtools_stderr, EXIT_FAILURE);
+            break;
+        }
+    }
+
+    if (opts.ga.nthreads > 0) {
+        if (!(opts.p.pool = hts_tpool_init(opts.ga.nthreads))) {
+            fprintf(samtools_stderr, "Failed to create thread pool\n");
+            if (rg.s)
+                free(rg.s);
+            return -1;;
+        }
+    }
+
+    int ret = import_fastq(argc-optind, argv+optind, &opts) ? 1 : 0;
+
+    if (rg.s)
+        free(rg.s);
+
+    if (opts.p.pool)
+        hts_tpool_destroy(opts.p.pool);
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_index.c

@@ -0,0 +1,289 @@
+/*  bam_index.c -- index and idxstats subcommands.
+
+    Copyright (C) 2008-2011, 2013-2016, 2018, 2019, 2023  Genome Research Ltd.
+    Portions copyright (C) 2010 Broad Institute.
+    Portions copyright (C) 2013 Peter Cock, The James Hutton Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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 notices 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.  */
+
+#include <config.h>
+
+#include <htslib/hts.h>
+#include <htslib/sam.h>
+#include <htslib/hfile.h>
+#include <htslib/khash.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <getopt.h>
+
+#include "samtools.h"
+#include "sam_opts.h"
+
+#define BAM_LIDX_SHIFT    14
+
+static void index_usage(FILE *fp)
+{
+    fprintf(fp,
+"Usage: samtools index -M [-bc] [-m INT] <in1.bam> <in2.bam>...\n"
+"   or: samtools index [-bc] [-m INT] <in.bam> [out.index]\n"
+"Options:\n"
+"  -b, --bai            Generate BAI-format index for BAM files [default]\n"
+"  -c, --csi            Generate CSI-format index for BAM files\n"
+"  -m, --min-shift INT  Set minimum interval size for CSI indices to 2^INT [%d]\n"
+"  -M                   Interpret all filename arguments as files to be indexed\n"
+"  -o, --output FILE    Write index to FILE [alternative to <out.index> in args]\n"
+"  -@, --threads INT    Sets the number of threads [none]\n", BAM_LIDX_SHIFT);
+}
+
+// Returns 1 if the file does not exist or can be positively
+// identified as an index file.
+static int nonexistent_or_index(const char *fn)
+{
+    int ret1, ret2;
+    htsFormat fmt;
+    hFILE *fp = hopen(fn, "r");
+    if (fp == NULL) return 1;
+
+    ret1 = hts_detect_format2(fp, fn, &fmt);
+    ret2 = hclose(fp);
+    if (ret1 < 0 || ret2 < 0) return 0;
+
+    return fmt.category == index_file;
+}
+
+int bam_index(int argc, char *argv[])
+{
+    int csi = 0;
+    int min_shift = BAM_LIDX_SHIFT;
+    int multiple = 0;
+    int n_threads = 0;
+    int n_files, c, i, ret;
+    const char *fn_idx = NULL;
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', '-', '-', '-', '-', '@'),
+        {"output",    required_argument, NULL, 'o'},
+        {"bai",       no_argument,       NULL, 'b'},
+        {"csi",       no_argument,       NULL, 'c'},
+        {"min-shift", required_argument, NULL, 'm'},
+        { NULL, 0, NULL, 0 }
+    };
+
+    while ((c = getopt_long(argc, argv, "bcm:Mo:@:", lopts, NULL)) >= 0)
+        switch (c) {
+        case 'b': csi = 0; break;
+        case 'c': csi = 1; break;
+        case 'm': csi = 1; min_shift = atoi(optarg); break;
+        case 'M': multiple = 1; break;
+        case 'o': fn_idx = optarg; break;
+        case '@': n_threads = atoi(optarg); break;
+        default:
+            index_usage(stderr);
+            return 1;
+        }
+
+    n_files = argc - optind;
+
+    if (n_files == 0) {
+        index_usage(stdout);
+        return 0;
+    }
+
+    // Handle legacy synopsis
+    if (n_files == 2 && !fn_idx && nonexistent_or_index(argv[optind+1])) {
+        n_files = 1;
+        fn_idx = argv[optind+1];
+    }
+
+    if (n_files > 1 && !multiple) {
+        print_error("index", "use -M to enable indexing more than one alignment file");
+        return EXIT_FAILURE;
+    }
+
+    if (fn_idx && n_files > 1) {
+        // TODO In future we may allow %* placeholders or similar
+        print_error("index", "can't use -o with multiple input alignment files");
+        return EXIT_FAILURE;
+    }
+
+    for (i = optind; i < optind + n_files; i++) {
+        ret = sam_index_build3(argv[i], fn_idx, csi? min_shift : 0, n_threads);
+        if (ret < 0) {
+            if (ret == -2)
+                print_error_errno("index", "failed to open \"%s\"", argv[i]);
+            else if (ret == -3)
+                print_error("index", "\"%s\" is in a format that cannot be usefully indexed", argv[i]);
+            else if (ret == -4 && fn_idx)
+                print_error("index", "failed to create or write index \"%s\"", fn_idx);
+            else if (ret == -4)
+                print_error("index", "failed to create or write index");
+            else
+                print_error_errno("index", "failed to create index for \"%s\"", argv[i]);
+            return EXIT_FAILURE;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+/*
+ * Cram indices do not contain mapped/unmapped record counts, so we have to
+ * decode each record and count.  However we can speed this up as much as
+ * possible by using the required fields parameter.
+ *
+ * This prints the stats to stdout in the same manner than the BAM function
+ * does.
+ *
+ * Returns 0 on success,
+ *        -1 on failure.
+ */
+int slow_idxstats(samFile *fp, sam_hdr_t *header) {
+    int ret, last_tid = -2;
+    bam1_t *b = bam_init1();
+
+    if (hts_set_opt(fp, CRAM_OPT_REQUIRED_FIELDS, SAM_RNAME | SAM_FLAG))
+        return -1;
+
+    uint64_t (*count0)[2] = calloc(sam_hdr_nref(header)+1, sizeof(*count0));
+    uint64_t (*counts)[2] = count0+1;
+    if (!count0)
+        return -1;
+
+    while ((ret = sam_read1(fp, header, b)) >= 0) {
+        if (b->core.tid >= sam_hdr_nref(header) || b->core.tid < -1) {
+            free(count0);
+            return -1;
+        }
+
+        if (b->core.tid != last_tid) {
+            if (last_tid >= -1) {
+                if (counts[b->core.tid][0] + counts[b->core.tid][1]) {
+                    print_error("idxstats", "file is not position sorted");
+                    free(count0);
+                    return -1;
+                }
+            }
+            last_tid = b->core.tid;
+        }
+
+        counts[b->core.tid][(b->core.flag & BAM_FUNMAP) ? 1 : 0]++;
+    }
+
+    if (ret == -1) {
+        int i;
+        for (i = 0; i < sam_hdr_nref(header); i++) {
+            printf("%s\t%"PRId64"\t%"PRIu64"\t%"PRIu64"\n",
+                   sam_hdr_tid2name(header, i),
+                   (int64_t) sam_hdr_tid2len(header, i),
+                   counts[i][0], counts[i][1]);
+        }
+        printf("*\t0\t%"PRIu64"\t%"PRIu64"\n", counts[-1][0], counts[-1][1]);
+    }
+
+    free(count0);
+
+    bam_destroy1(b);
+
+    return (ret == -1) ? 0 : -1;
+}
+
+static void usage_exit(FILE *fp, int exit_status)
+{
+    fprintf(fp, "Usage: samtools idxstats [options] <in.bam>\n");
+    sam_global_opt_help(fp, "-.---@-.");
+    exit(exit_status);
+}
+
+int bam_idxstats(int argc, char *argv[])
+{
+    hts_idx_t* idx;
+    sam_hdr_t* header;
+    samFile* fp;
+    int c;
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', '-', '@'),
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "@:", lopts, NULL)) >= 0) {
+        switch (c) {
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage_exit(stderr, EXIT_FAILURE);
+        }
+    }
+
+    if (argc != optind+1) {
+        if (argc == optind) usage_exit(stdout, EXIT_SUCCESS);
+        else usage_exit(stderr, EXIT_FAILURE);
+    }
+
+    fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (fp == NULL) {
+        print_error_errno("idxstats", "failed to open \"%s\"", argv[optind]);
+        return 1;
+    }
+    header = sam_hdr_read(fp);
+    if (header == NULL) {
+        print_error("idxstats", "failed to read header for \"%s\"", argv[optind]);
+        return 1;
+    }
+
+    if (hts_get_format(fp)->format != bam) {
+    slow_method:
+        if (ga.nthreads)
+            hts_set_threads(fp, ga.nthreads);
+
+        if (slow_idxstats(fp, header) < 0) {
+            print_error("idxstats", "failed to process \"%s\"", argv[optind]);
+            return 1;
+        }
+    } else {
+        idx = sam_index_load(fp, argv[optind]);
+        if (idx == NULL) {
+            print_error("idxstats", "fail to load index for \"%s\", "
+                        "reverting to slow method", argv[optind]);
+            goto slow_method;
+        }
+
+        int i;
+        for (i = 0; i < sam_hdr_nref(header); ++i) {
+            // Print out contig name and length
+            printf("%s\t%"PRId64, sam_hdr_tid2name(header, i), (int64_t) sam_hdr_tid2len(header, i));
+            // Now fetch info about it from the meta bin
+            uint64_t u, v;
+            hts_idx_get_stat(idx, i, &u, &v);
+            printf("\t%" PRIu64 "\t%" PRIu64 "\n", u, v);
+        }
+        // Dump information about unmapped reads
+        printf("*\t0\t0\t%" PRIu64 "\n", hts_idx_get_n_no_coor(idx));
+        hts_idx_destroy(idx);
+    }
+
+    sam_hdr_destroy(header);
+    sam_close(fp);
+    return 0;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_index.c.pysam.c

@@ -0,0 +1,291 @@
+#include "samtools.pysam.h"
+
+/*  bam_index.c -- index and idxstats subcommands.
+
+    Copyright (C) 2008-2011, 2013-2016, 2018, 2019, 2023  Genome Research Ltd.
+    Portions copyright (C) 2010 Broad Institute.
+    Portions copyright (C) 2013 Peter Cock, The James Hutton Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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 notices 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.  */
+
+#include <config.h>
+
+#include <htslib/hts.h>
+#include <htslib/sam.h>
+#include <htslib/hfile.h>
+#include <htslib/khash.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <getopt.h>
+
+#include "samtools.h"
+#include "sam_opts.h"
+
+#define BAM_LIDX_SHIFT    14
+
+static void index_usage(FILE *fp)
+{
+    fprintf(fp,
+"Usage: samtools index -M [-bc] [-m INT] <in1.bam> <in2.bam>...\n"
+"   or: samtools index [-bc] [-m INT] <in.bam> [out.index]\n"
+"Options:\n"
+"  -b, --bai            Generate BAI-format index for BAM files [default]\n"
+"  -c, --csi            Generate CSI-format index for BAM files\n"
+"  -m, --min-shift INT  Set minimum interval size for CSI indices to 2^INT [%d]\n"
+"  -M                   Interpret all filename arguments as files to be indexed\n"
+"  -o, --output FILE    Write index to FILE [alternative to <out.index> in args]\n"
+"  -@, --threads INT    Sets the number of threads [none]\n", BAM_LIDX_SHIFT);
+}
+
+// Returns 1 if the file does not exist or can be positively
+// identified as an index file.
+static int nonexistent_or_index(const char *fn)
+{
+    int ret1, ret2;
+    htsFormat fmt;
+    hFILE *fp = hopen(fn, "r");
+    if (fp == NULL) return 1;
+
+    ret1 = hts_detect_format2(fp, fn, &fmt);
+    ret2 = hclose(fp);
+    if (ret1 < 0 || ret2 < 0) return 0;
+
+    return fmt.category == index_file;
+}
+
+int bam_index(int argc, char *argv[])
+{
+    int csi = 0;
+    int min_shift = BAM_LIDX_SHIFT;
+    int multiple = 0;
+    int n_threads = 0;
+    int n_files, c, i, ret;
+    const char *fn_idx = NULL;
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', '-', '-', '-', '-', '@'),
+        {"output",    required_argument, NULL, 'o'},
+        {"bai",       no_argument,       NULL, 'b'},
+        {"csi",       no_argument,       NULL, 'c'},
+        {"min-shift", required_argument, NULL, 'm'},
+        { NULL, 0, NULL, 0 }
+    };
+
+    while ((c = getopt_long(argc, argv, "bcm:Mo:@:", lopts, NULL)) >= 0)
+        switch (c) {
+        case 'b': csi = 0; break;
+        case 'c': csi = 1; break;
+        case 'm': csi = 1; min_shift = atoi(optarg); break;
+        case 'M': multiple = 1; break;
+        case 'o': fn_idx = optarg; break;
+        case '@': n_threads = atoi(optarg); break;
+        default:
+            index_usage(samtools_stderr);
+            return 1;
+        }
+
+    n_files = argc - optind;
+
+    if (n_files == 0) {
+        index_usage(samtools_stdout);
+        return 0;
+    }
+
+    // Handle legacy synopsis
+    if (n_files == 2 && !fn_idx && nonexistent_or_index(argv[optind+1])) {
+        n_files = 1;
+        fn_idx = argv[optind+1];
+    }
+
+    if (n_files > 1 && !multiple) {
+        print_error("index", "use -M to enable indexing more than one alignment file");
+        return EXIT_FAILURE;
+    }
+
+    if (fn_idx && n_files > 1) {
+        // TODO In future we may allow %* placeholders or similar
+        print_error("index", "can't use -o with multiple input alignment files");
+        return EXIT_FAILURE;
+    }
+
+    for (i = optind; i < optind + n_files; i++) {
+        ret = sam_index_build3(argv[i], fn_idx, csi? min_shift : 0, n_threads);
+        if (ret < 0) {
+            if (ret == -2)
+                print_error_errno("index", "failed to open \"%s\"", argv[i]);
+            else if (ret == -3)
+                print_error("index", "\"%s\" is in a format that cannot be usefully indexed", argv[i]);
+            else if (ret == -4 && fn_idx)
+                print_error("index", "failed to create or write index \"%s\"", fn_idx);
+            else if (ret == -4)
+                print_error("index", "failed to create or write index");
+            else
+                print_error_errno("index", "failed to create index for \"%s\"", argv[i]);
+            return EXIT_FAILURE;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}
+
+/*
+ * Cram indices do not contain mapped/unmapped record counts, so we have to
+ * decode each record and count.  However we can speed this up as much as
+ * possible by using the required fields parameter.
+ *
+ * This prints the stats to samtools_stdout in the same manner than the BAM function
+ * does.
+ *
+ * Returns 0 on success,
+ *        -1 on failure.
+ */
+int slow_idxstats(samFile *fp, sam_hdr_t *header) {
+    int ret, last_tid = -2;
+    bam1_t *b = bam_init1();
+
+    if (hts_set_opt(fp, CRAM_OPT_REQUIRED_FIELDS, SAM_RNAME | SAM_FLAG))
+        return -1;
+
+    uint64_t (*count0)[2] = calloc(sam_hdr_nref(header)+1, sizeof(*count0));
+    uint64_t (*counts)[2] = count0+1;
+    if (!count0)
+        return -1;
+
+    while ((ret = sam_read1(fp, header, b)) >= 0) {
+        if (b->core.tid >= sam_hdr_nref(header) || b->core.tid < -1) {
+            free(count0);
+            return -1;
+        }
+
+        if (b->core.tid != last_tid) {
+            if (last_tid >= -1) {
+                if (counts[b->core.tid][0] + counts[b->core.tid][1]) {
+                    print_error("idxstats", "file is not position sorted");
+                    free(count0);
+                    return -1;
+                }
+            }
+            last_tid = b->core.tid;
+        }
+
+        counts[b->core.tid][(b->core.flag & BAM_FUNMAP) ? 1 : 0]++;
+    }
+
+    if (ret == -1) {
+        int i;
+        for (i = 0; i < sam_hdr_nref(header); i++) {
+            fprintf(samtools_stdout, "%s\t%"PRId64"\t%"PRIu64"\t%"PRIu64"\n",
+                   sam_hdr_tid2name(header, i),
+                   (int64_t) sam_hdr_tid2len(header, i),
+                   counts[i][0], counts[i][1]);
+        }
+        fprintf(samtools_stdout, "*\t0\t%"PRIu64"\t%"PRIu64"\n", counts[-1][0], counts[-1][1]);
+    }
+
+    free(count0);
+
+    bam_destroy1(b);
+
+    return (ret == -1) ? 0 : -1;
+}
+
+static void usage_exit(FILE *fp, int exit_status)
+{
+    fprintf(fp, "Usage: samtools idxstats [options] <in.bam>\n");
+    sam_global_opt_help(fp, "-.---@-.");
+    samtools_exit(exit_status);
+}
+
+int bam_idxstats(int argc, char *argv[])
+{
+    hts_idx_t* idx;
+    sam_hdr_t* header;
+    samFile* fp;
+    int c;
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', '-', '@'),
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "@:", lopts, NULL)) >= 0) {
+        switch (c) {
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage_exit(samtools_stderr, EXIT_FAILURE);
+        }
+    }
+
+    if (argc != optind+1) {
+        if (argc == optind) usage_exit(samtools_stdout, EXIT_SUCCESS);
+        else usage_exit(samtools_stderr, EXIT_FAILURE);
+    }
+
+    fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (fp == NULL) {
+        print_error_errno("idxstats", "failed to open \"%s\"", argv[optind]);
+        return 1;
+    }
+    header = sam_hdr_read(fp);
+    if (header == NULL) {
+        print_error("idxstats", "failed to read header for \"%s\"", argv[optind]);
+        return 1;
+    }
+
+    if (hts_get_format(fp)->format != bam) {
+    slow_method:
+        if (ga.nthreads)
+            hts_set_threads(fp, ga.nthreads);
+
+        if (slow_idxstats(fp, header) < 0) {
+            print_error("idxstats", "failed to process \"%s\"", argv[optind]);
+            return 1;
+        }
+    } else {
+        idx = sam_index_load(fp, argv[optind]);
+        if (idx == NULL) {
+            print_error("idxstats", "fail to load index for \"%s\", "
+                        "reverting to slow method", argv[optind]);
+            goto slow_method;
+        }
+
+        int i;
+        for (i = 0; i < sam_hdr_nref(header); ++i) {
+            // Print out contig name and length
+            fprintf(samtools_stdout, "%s\t%"PRId64, sam_hdr_tid2name(header, i), (int64_t) sam_hdr_tid2len(header, i));
+            // Now fetch info about it from the meta bin
+            uint64_t u, v;
+            hts_idx_get_stat(idx, i, &u, &v);
+            fprintf(samtools_stdout, "\t%" PRIu64 "\t%" PRIu64 "\n", u, v);
+        }
+        // Dump information about unmapped reads
+        fprintf(samtools_stdout, "*\t0\t0\t%" PRIu64 "\n", hts_idx_get_n_no_coor(idx));
+        hts_idx_destroy(idx);
+    }
+
+    sam_hdr_destroy(header);
+    sam_close(fp);
+    return 0;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_lpileup.c

@@ -0,0 +1,225 @@
+/*  bam_lpileup.c -- lplbuf routines.
+
+    Copyright (C) 2008, 2009, 2013 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include "bam_plbuf.h"
+#include "bam_lpileup.h"
+#include "splaysort.h"
+
+#define TV_GAP 2
+
+typedef struct __freenode_t {
+    uint32_t level:28, cnt:4;
+    struct __freenode_t *next;
+} freenode_t, *freenode_p;
+
+#define freenode_lt(a,b) ((a)->cnt < (b)->cnt || ((a)->cnt == (b)->cnt && (a)->level < (b)->level))
+SPLAYSORT_INIT(node, freenode_p, freenode_lt)
+
+/* Memory pool, similar to the one in bam_pileup.c */
+typedef struct {
+    int cnt, n, max;
+    freenode_t **buf;
+} mempool_t;
+
+static mempool_t *mp_init(void)
+{
+    return (mempool_t*)calloc(1, sizeof(mempool_t));
+}
+static void mp_destroy(mempool_t *mp)
+{
+    int k;
+    for (k = 0; k < mp->n; ++k) free(mp->buf[k]);
+    free(mp->buf); free(mp);
+}
+static inline freenode_t *mp_alloc(mempool_t *mp)
+{
+    ++mp->cnt;
+    if (mp->n == 0) return (freenode_t*)calloc(1, sizeof(freenode_t));
+    else return mp->buf[--mp->n];
+}
+static inline void mp_free(mempool_t *mp, freenode_t *p)
+{
+    --mp->cnt; p->next = 0; p->cnt = TV_GAP;
+    if (mp->n == mp->max) {
+        mp->max = mp->max? mp->max<<1 : 256;
+        mp->buf = (freenode_t**)realloc(mp->buf, sizeof(freenode_t*) * mp->max);
+    }
+    mp->buf[mp->n++] = p;
+}
+
+/* core part */
+struct __bam_lplbuf_t {
+    int max, n_cur, n_pre;
+    int max_level, *cur_level, *pre_level;
+    mempool_t *mp;
+    freenode_t **aux, *head, *tail;
+    int n_nodes, m_aux;
+    bam_pileup_f func;
+    void *user_data;
+    bam_plbuf_t *plbuf;
+};
+
+void bam_lplbuf_reset(bam_lplbuf_t *buf)
+{
+    freenode_t *p, *q;
+    bam_plbuf_reset(buf->plbuf);
+    for (p = buf->head; p->next;) {
+        q = p->next;
+        mp_free(buf->mp, p);
+        p = q;
+    }
+    buf->head = buf->tail;
+    buf->max_level = 0;
+    buf->n_cur = buf->n_pre = 0;
+    buf->n_nodes = 0;
+}
+
+static int tview_func(uint32_t tid, hts_pos_t pos, int n, const bam_pileup1_t *pl, void *data)
+{
+    bam_lplbuf_t *tv = (bam_lplbuf_t*)data;
+    freenode_t *p;
+    int i, l, max_level;
+    // allocate memory if necessary
+    if (tv->max < n) { // enlarge
+        tv->max = n;
+        kroundup32(tv->max);
+        tv->cur_level = (int*)realloc(tv->cur_level, sizeof(int) * tv->max);
+        tv->pre_level = (int*)realloc(tv->pre_level, sizeof(int) * tv->max);
+    }
+    tv->n_cur = n;
+    // update cnt
+    for (p = tv->head; p->next; p = p->next)
+        if (p->cnt > 0) --p->cnt;
+    // calculate cur_level[]
+    max_level = 0;
+    for (i = l = 0; i < n; ++i) {
+        const bam_pileup1_t *p = pl + i;
+        if (p->is_head) {
+            if (tv->head->next && tv->head->cnt == 0) { // then take a free slot
+                freenode_t *p = tv->head->next;
+                tv->cur_level[i] = tv->head->level;
+                mp_free(tv->mp, tv->head);
+                tv->head = p;
+                --tv->n_nodes;
+            } else tv->cur_level[i] = ++tv->max_level;
+        } else {
+            tv->cur_level[i] = tv->pre_level[l++];
+            if (p->is_tail) { // then return a free slot
+                tv->tail->level = tv->cur_level[i];
+                tv->tail->next = mp_alloc(tv->mp);
+                tv->tail = tv->tail->next;
+                ++tv->n_nodes;
+            }
+        }
+        if (tv->cur_level[i] > max_level) max_level = tv->cur_level[i];
+        ((bam_pileup1_t*)p)->level = tv->cur_level[i];
+    }
+    assert(l == tv->n_pre);
+    tv->func(tid, pos, n, pl, tv->user_data);
+    // sort the linked list
+    if (tv->n_nodes) {
+        freenode_t *q;
+        if (tv->n_nodes + 1 > tv->m_aux) { // enlarge
+            tv->m_aux = tv->n_nodes + 1;
+            kroundup32(tv->m_aux);
+            tv->aux = (freenode_t**)realloc(tv->aux, sizeof(freenode_t*) * tv->m_aux);
+        }
+        for (p = tv->head, i = l = 0; p->next;) {
+            if (p->level > max_level) { // then discard this entry
+                q = p->next;
+                mp_free(tv->mp, p);
+                p = q;
+            } else {
+                tv->aux[i++] = p;
+                p = p->next;
+            }
+        }
+        tv->aux[i] = tv->tail; // add a proper tail for the loop below
+        tv->n_nodes = i;
+        if (tv->n_nodes) {
+            splaysort(node, tv->n_nodes, tv->aux);
+            for (i = 0; i < tv->n_nodes; ++i) tv->aux[i]->next = tv->aux[i+1];
+            tv->head = tv->aux[0];
+        } else tv->head = tv->tail;
+    }
+    // clean up
+    tv->max_level = max_level;
+    memcpy(tv->pre_level, tv->cur_level, tv->n_cur * 4);
+    // squeeze out terminated levels
+    for (i = l = 0; i < n; ++i) {
+        const bam_pileup1_t *p = pl + i;
+        if (!p->is_tail)
+            tv->pre_level[l++] = tv->pre_level[i];
+    }
+    tv->n_pre = l;
+/*
+    fprintf(stderr, "%d\t", pos+1);
+    for (i = 0; i < n; ++i) {
+        const bam_pileup1_t *p = pl + i;
+        if (p->is_head) fprintf(stderr, "^");
+        if (p->is_tail) fprintf(stderr, "$");
+        fprintf(stderr, "%d,", p->level);
+    }
+    fprintf(stderr, "\n");
+*/
+    return 0;
+}
+
+bam_lplbuf_t *bam_lplbuf_init(bam_pileup_f func, void *data)
+{
+    bam_lplbuf_t *tv;
+    tv = (bam_lplbuf_t*)calloc(1, sizeof(bam_lplbuf_t));
+    tv->mp = mp_init();
+    tv->head = tv->tail = mp_alloc(tv->mp);
+    tv->func = func;
+    tv->user_data = data;
+    tv->plbuf = bam_plbuf_init(tview_func, tv);
+    return (bam_lplbuf_t*)tv;
+}
+
+void bam_lplbuf_destroy(bam_lplbuf_t *tv)
+{
+    freenode_t *p, *q;
+    free(tv->cur_level); free(tv->pre_level);
+    bam_plbuf_destroy(tv->plbuf);
+    free(tv->aux);
+    for (p = tv->head; p->next;) {
+        q = p->next;
+        mp_free(tv->mp, p); p = q;
+    }
+    mp_free(tv->mp, p);
+    assert(tv->mp->cnt == 0);
+    mp_destroy(tv->mp);
+    free(tv);
+}
+
+int bam_lplbuf_push(const bam1_t *b, bam_lplbuf_t *tv)
+{
+    return bam_plbuf_push(b, tv->plbuf);
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_lpileup.h

@@ -0,0 +1,57 @@
+/*  bam_lpileup.h -- lplbuf routines (declarations copied from bam.h).
+
+    Copyright (C) 2008, 2013 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#ifndef BAM_LPILEUP_H
+#define BAM_LPILEUP_H
+
+
+#include <htslib/sam.h>
+
+struct __bam_lplbuf_t;
+typedef struct __bam_lplbuf_t bam_lplbuf_t;
+
+#ifndef BAM_PILEUP_F_DEFINED
+#define BAM_PILEUP_F_DEFINED
+typedef int (*bam_pileup_f)(uint32_t tid, hts_pos_t pos, int n, const bam_pileup1_t *pl, void *data);
+#endif //BAM_PILEUP_F_DEFINED
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    void bam_lplbuf_reset(bam_lplbuf_t *buf);
+
+    /*! @abstract  bam_plbuf_init() equivalent with level calculated. */
+    bam_lplbuf_t *bam_lplbuf_init(bam_pileup_f func, void *data);
+
+    /*! @abstract  bam_plbuf_destroy() equivalent with level calculated. */
+    void bam_lplbuf_destroy(bam_lplbuf_t *tv);
+
+    /*! @abstract  bam_plbuf_push() equivalent with level calculated. */
+    int bam_lplbuf_push(const bam1_t *b, bam_lplbuf_t *buf);
+#ifdef __cplusplus
+}
+#endif
+
+#endif // BAM_LPILEUP_H

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_markdup.c

@@ -0,0 +1,2510 @@
+/*  bam_markdup.c -- Mark duplicates from a coord sorted file that has gone
+                     through fixmates with the mate scoring option on.
+
+    Copyright (C) 2017-2023 Genome Research Ltd.
+
+    Author: Andrew Whitwham <aw7@sanger.ac.uk>
+
+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
+
+Estimate library size derived from Picard DuplicationMetrics.java
+Copyright (c) 2009,2018 The Broad Institute.  MIT license.
+*/
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <regex.h>
+#include "htslib/thread_pool.h"
+#include "htslib/sam.h"
+#include "sam_opts.h"
+#include "samtools.h"
+#include "htslib/khash.h"
+#include "htslib/klist.h"
+#include "htslib/kstring.h"
+#include "tmp_file.h"
+#include "bam.h"
+
+
+typedef struct {
+    samFile *in;
+    samFile *out;
+    char *prefix;
+    int remove_dups;
+    int32_t max_length;
+    int do_stats;
+    int supp;
+    int tag;
+    int opt_dist;
+    int no_pg;
+    int clear;
+    int mode;
+    int write_index;
+    int include_fails;
+    int check_chain;
+    char *stats_file;
+    char *arg_list;
+    char *out_fn;
+    regex_t *rgx;
+    int rgx_x;
+    int rgx_y;
+    int rgx_t;
+    char *barcode;
+    regex_t *bc_rgx;
+    int read_groups;
+    int json;
+    int dc;
+} md_param_t;
+
+typedef struct {
+    hts_pos_t this_coord;
+    hts_pos_t other_coord;
+    int32_t this_ref;
+    int32_t other_ref;
+    int32_t barcode;
+    int32_t read_group;
+    int8_t single;
+    int8_t leftmost;
+    int8_t orientation;
+} key_data_t;
+
+typedef struct read_queue_s {
+    key_data_t pair_key;
+    key_data_t single_key;
+    bam1_t *b;
+    struct read_queue_s *duplicate;
+    struct read_queue_s *original;
+    int dc;
+    hts_pos_t pos;
+    int dup_checked;
+    int read_group;
+} read_queue_t;
+
+typedef struct {
+    read_queue_t *p;
+} in_hash_t;
+
+typedef struct {
+    char *name;
+    char type;
+    int read_group;
+} dup_map_t;
+
+typedef struct {
+    bam1_t *b;
+    int64_t score;
+    int64_t mate_score;
+    long x;
+    long y;
+    int opt;
+    int beg;
+    int end;
+} check_t;
+
+typedef struct {
+    check_t *c;
+    size_t size;
+    size_t length;
+} check_list_t;
+
+typedef struct {
+    long reading;
+    long writing;
+    long excluded;
+    long duplicate;
+    long single;
+    long pair;
+    long single_dup;
+    long examined;
+    long optical;
+    long single_optical;
+    long np_duplicate;
+    long np_opt_duplicate;
+} stats_block_t;
+
+static khint32_t do_hash(unsigned char *key, khint32_t len);
+
+static khint_t hash_key(key_data_t key) {
+    int i = 0;
+    khint_t hash;
+
+    if (key.single) {
+        unsigned char sig[21];
+
+        memcpy(sig + i, &key.this_ref, 4);      i += 4;
+        memcpy(sig + i, &key.this_coord, 8);    i += 8;
+        memcpy(sig + i, &key.orientation, 1);   i += 1;
+        memcpy(sig + i, &key.barcode, 4);       i += 4;
+        memcpy(sig + i, &key.read_group, 4);    i += 4;
+
+        hash = do_hash(sig, i);
+    } else {
+        unsigned char sig[34];
+
+        memcpy(sig + i, &key.this_ref, 4);      i += 4;
+        memcpy(sig + i, &key.this_coord, 8);    i += 8;
+        memcpy(sig + i, &key.other_ref, 4);     i += 4;
+        memcpy(sig + i, &key.other_coord, 8);   i += 8;
+        memcpy(sig + i, &key.leftmost, 1);      i += 1;
+        memcpy(sig + i, &key.orientation, 1);   i += 1;
+        memcpy(sig + i, &key.barcode, 4);       i += 4;
+        memcpy(sig + i, &key.read_group, 4);    i += 4;
+
+        hash = do_hash(sig, i);
+    }
+
+    return hash;
+}
+
+
+static int key_equal(key_data_t a, key_data_t b) {
+    int match = 1;
+
+    if (a.this_coord != b.this_coord)
+        match = 0;
+    else if (a.orientation != b.orientation)
+        match = 0;
+    else if (a.this_ref != b.this_ref)
+        match = 0;
+    else if (a.single != b.single)
+        match = 0;
+    else if (a.barcode != b.barcode)
+        match = 0;
+    else if (a.read_group != b.read_group)
+        match = 0;
+
+    if (!a.single) {
+        if (a.other_coord != b.other_coord)
+            match = 0;
+        else if (a.leftmost != b.leftmost)
+            match = 0;
+        else if (a.other_ref != b.other_ref)
+            match = 0;
+    }
+
+    return match;
+}
+
+
+#define __free_queue_element(p)
+
+// Orientations (prime numbers to feed to hashing algorithm)
+#define O_FF 2
+#define O_RR 3
+#define O_FR 5
+#define O_RF 7
+
+// Left or rightmost
+#define R_LE 11
+#define R_RI 13
+
+#define BMD_WARNING_MAX 10
+
+#define MD_MIN_QUALITY 15
+
+// Duplicate finding mode
+#define MD_MODE_TEMPLATE 0
+#define MD_MODE_SEQUENCE 1
+
+KHASH_INIT(reads, key_data_t, in_hash_t, 1, hash_key, key_equal) // read map hash
+KLIST_INIT(read_queue, read_queue_t, __free_queue_element) // the reads buffer
+KHASH_MAP_INIT_STR(duplicates, dup_map_t) // map of duplicates for supplementary dup id
+KHASH_MAP_INIT_STR(read_groups, int) // read group lookup
+
+/* The Bob Jenkins one_at_a_time hash to reduce the key to a 32 bit value. */
+
+static khint32_t do_hash(unsigned char *key, khint32_t len) {
+    khint32_t   hash, i;
+
+    for (hash = 0, i = 0; i < len; ++i) {
+        hash += key[i];
+        hash += (hash << 10);
+        hash ^= (hash >> 6);
+    }
+
+    hash += (hash << 3);
+    hash ^= (hash >> 11);
+    hash += (hash << 15);
+
+    return hash;
+}
+
+
+/* Get mate score from tag. */
+
+static int64_t get_mate_score(bam1_t *b) {
+    uint8_t *data;
+    int64_t score;
+
+    if ((data = bam_aux_get(b, "ms"))) {
+        score = bam_aux2i(data);
+    } else {
+        print_error("markdup", "error, no ms score tag. Please run samtools fixmate on file first.\n");
+        return -1;
+    }
+
+    return score;
+}
+
+
+/* Calc current score from quality. */
+
+static int64_t calc_score(bam1_t *b)
+{
+    int64_t score = 0;
+    uint8_t  *qual = bam_get_qual(b);
+    int i;
+
+    for (i = 0; i < b->core.l_qseq; i++) {
+        if (qual[i] >= MD_MIN_QUALITY) score += qual[i];
+    }
+
+    return score;
+}
+
+
+/* Create a signature hash of the current read and its pair.
+   Uses the unclipped start (or end depending on orientation),
+   the reference id, orientation and whether the current
+   read is leftmost of the pair. */
+
+
+static int make_pair_key(md_param_t *param, key_data_t *key, bam1_t *bam, int rg_num, long *warnings) {
+     hts_pos_t this_coord, this_end, other_coord, other_end, leftmost;
+    int32_t this_ref, other_ref, barcode = 0;
+    int8_t orientation, left_read;
+    uint8_t *data;
+    char *cig, *bar;
+    long incoming_warnings = *warnings;
+
+    this_ref    = bam->core.tid + 1; // avoid a 0 being put into the hash
+    other_ref   = bam->core.mtid + 1;
+
+    this_coord = unclipped_start(bam);
+    this_end   = unclipped_end(bam);
+
+    if ((data = bam_aux_get(bam, "MC"))) {
+        if (!(cig = bam_aux2Z(data))) {
+            print_error("markdup", "error, MC tag wrong type. Please use the MC tag provided by samtools fixmate.\n");
+            return 1;
+        }
+
+        other_end   = unclipped_other_end(bam->core.mpos, cig);
+        other_coord = unclipped_other_start(bam->core.mpos, cig);
+    } else {
+        print_error("markdup", "error, no MC tag. Please run samtools fixmate on file first.\n");
+        return 1;
+    }
+
+    // work out orientations
+    if (param->mode == MD_MODE_TEMPLATE) {
+
+        if (this_ref != other_ref) {
+            leftmost = this_ref < other_ref;
+        } else {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+                if (!bam_is_rev(bam)) {
+                    leftmost = this_coord <= other_coord;
+                } else {
+                    leftmost = this_end <= other_end;
+                }
+            } else {
+                if (bam_is_rev(bam)) {
+                    leftmost = this_end <= other_coord;
+                } else {
+                    leftmost = this_coord <= other_end;
+                }
+            }
+        }
+
+        // pair orientation
+        if (leftmost) {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+                other_coord = other_end;
+
+                if (!bam_is_rev(bam)) {
+                    if (bam->core.flag & BAM_FREAD1) {
+                        orientation = O_FF;
+                    } else {
+                        orientation = O_RR;
+                    }
+                } else {
+                    if (bam->core.flag & BAM_FREAD1) {
+                        orientation = O_RR;
+                    } else {
+                        orientation = O_FF;
+                    }
+                }
+            } else {
+                if (!bam_is_rev(bam)) {
+                    orientation = O_FR;
+                    other_coord = other_end;
+                } else {
+                    orientation = O_RF;
+                    this_coord = this_end;
+                }
+            }
+        } else {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+                this_coord = this_end;
+
+                if (!bam_is_rev(bam)) {
+                    if (bam->core.flag & BAM_FREAD1) {
+                        orientation = O_RR;
+                    } else {
+                        orientation = O_FF;
+                    }
+                } else {
+                    if (bam->core.flag & BAM_FREAD1) {
+                        orientation = O_FF;
+                    } else {
+                        orientation = O_RR;
+                    }
+                }
+            } else {
+                if (!bam_is_rev(bam)) {
+                    orientation = O_RF;
+                    other_coord = other_end;
+                } else {
+                    orientation = O_FR;
+                    this_coord = this_end;
+                }
+            }
+        }
+    } else { // MD_MODE_SEQUENCE
+
+        if (this_ref != other_ref) {
+            leftmost = this_ref - other_ref;
+        } else {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+                if (!bam_is_rev(bam)) {
+                    leftmost = this_coord - other_coord;
+                } else {
+                    leftmost = this_end - other_end;
+                }
+            } else {
+                if (bam_is_rev(bam)) {
+                    leftmost = this_end - other_coord;
+                } else {
+                    leftmost = this_coord - other_end;
+                }
+            }
+        }
+
+        if (leftmost < 0) {
+            leftmost = 1;
+        } else if (leftmost > 0) {
+            leftmost = 0;
+        } else {
+            // tie breaks
+
+            if (bam->core.pos == bam->core.mpos) {
+                if (bam->core.flag & BAM_FREAD1) {
+                    leftmost = 1;
+                } else {
+                    leftmost = 0;
+                }
+            } else if (bam->core.pos < bam->core.mpos) {
+                leftmost = 1;
+            } else {
+                leftmost = 0;
+            }
+        }
+
+        // pair orientation
+        if (leftmost) {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+
+                if (!bam_is_rev(bam)) {
+                        orientation = O_FF;
+                } else {
+                        orientation = O_RR;
+                }
+            } else {
+                if (!bam_is_rev(bam)) {
+                    orientation = O_FR;
+                } else {
+                    orientation = O_RF;
+                }
+            }
+        } else {
+            if (bam_is_rev(bam) == bam_is_mrev(bam)) {
+
+                if (!bam_is_rev(bam)) {
+                        orientation = O_RR;
+                } else {
+                        orientation = O_FF;
+                }
+            } else {
+                if (!bam_is_rev(bam)) {
+                    orientation = O_RF;
+                } else {
+                    orientation = O_FR;
+                }
+            }
+        }
+
+        if (!bam_is_rev(bam)) {
+            this_coord = unclipped_start(bam);
+        } else {
+            this_coord = unclipped_end(bam);
+        }
+
+        if (!bam_is_mrev(bam)) {
+            other_coord = unclipped_other_start(bam->core.mpos, cig);
+        } else {
+            other_coord = unclipped_other_end(bam->core.mpos, cig);
+        }
+    }
+
+    if (!leftmost)
+        left_read = R_RI;
+    else
+        left_read = R_LE;
+
+    if (param->barcode) {
+        if ((data = bam_aux_get(bam, param->barcode))) {
+            if (!(bar = bam_aux2Z(data))) {
+                (*warnings)++;
+
+                if (*warnings <= BMD_WARNING_MAX) {
+                    print_error("markdup", "warning, %s tag wrong type. Aux tag needs to be a string type.\n", param->barcode);
+                }
+            } else {
+                barcode = do_hash((unsigned char *)bar, strlen(bar));
+            }
+        }
+    } else if (param->bc_rgx) {
+        int result;
+        regmatch_t matches[3];
+        size_t max_matches = 2;
+        char *qname = bam_get_qname(bam);
+
+        if ((result = regexec(param->bc_rgx, qname, max_matches, matches, 0)) == 0) {
+            int bc_start, bc_end;
+
+            bc_start = matches[1].rm_so;
+            bc_end   = matches[1].rm_eo;
+
+            if (bc_start != -1) {
+                barcode = do_hash((unsigned char *)qname + bc_start, bc_end - bc_start);
+            } else {
+                (*warnings)++;
+
+                if (*warnings <= BMD_WARNING_MAX) {
+                    print_error("markdup", "warning, barcode regex unable to match substring on %s.\n", qname);
+                }
+            }
+        } else {
+            (*warnings)++;
+
+            if (*warnings <= BMD_WARNING_MAX) {
+                char warn_msg[256];
+
+                regerror(result, param->bc_rgx, warn_msg, 256);
+                print_error("markdup", "warning, barcode regex match error \"%s\" on %s.\n", warn_msg, qname);
+            }
+        }
+    }
+
+    if ((*warnings == BMD_WARNING_MAX) && (incoming_warnings != *warnings)) {
+        print_error("markdup", "warning, %ld barcode read warnings.  New warnings will not be reported.\n",
+                        *warnings);
+    }
+
+    key->single        = 0;
+    key->this_ref      = this_ref;
+    key->this_coord    = this_coord;
+    key->other_ref     = other_ref;
+    key->other_coord   = other_coord;
+    key->leftmost      = left_read;
+    key->orientation   = orientation;
+    key->barcode       = barcode;
+    key->read_group    = rg_num;
+
+    return 0;
+}
+
+
+/* Create a signature hash of single read (or read with an unmatched pair).
+   Uses unclipped start (or end depending on orientation), reference id,
+   and orientation. */
+
+static void make_single_key(md_param_t *param, key_data_t *key, bam1_t *bam, int rg_num, long *warnings) {
+    hts_pos_t this_coord;
+    int32_t this_ref, barcode = 0;
+    int8_t orientation;
+    uint8_t *data;
+    char *bar;
+    long incoming_warnings = *warnings;
+
+    this_ref = bam->core.tid + 1; // avoid a 0 being put into the hash
+
+    if (bam_is_rev(bam)) {
+        this_coord = unclipped_end(bam);
+        orientation = O_RR;
+    } else {
+        this_coord = unclipped_start(bam);
+        orientation = O_FF;
+    }
+
+    if (param->barcode) {
+        if ((data = bam_aux_get(bam, param->barcode))) {
+            if (!(bar = bam_aux2Z(data))) {
+                (*warnings)++;
+
+                if (*warnings <= BMD_WARNING_MAX) {
+                    print_error("markdup", "warning, %s tag wrong type. Aux tag needs to be a string type.\n", param->barcode);
+                }
+            } else {
+                barcode = do_hash((unsigned char *)bar, strlen(bar));
+            }
+        }
+    } else if (param->bc_rgx) {
+        int result;
+        regmatch_t matches[3];
+        size_t max_matches = 2;
+        char *qname = bam_get_qname(bam);
+
+        if ((result = regexec(param->bc_rgx, qname, max_matches, matches, 0)) == 0) {
+            int bc_start, bc_end;
+
+            bc_start = matches[1].rm_so;
+            bc_end   = matches[1].rm_eo;
+
+            if (bc_start != -1) {
+                barcode = do_hash((unsigned char *)qname + bc_start, bc_end - bc_start);
+            } else {
+                (*warnings)++;
+
+                if (*warnings <= BMD_WARNING_MAX) {
+                    print_error("markdup", "warning, barcode regex unable to match substring on %s.\n", qname);
+                }
+            }
+        } else {
+            (*warnings)++;
+
+            if (*warnings <= BMD_WARNING_MAX) {
+                char warn_msg[256];
+
+                regerror(result, param->bc_rgx, warn_msg, 256);
+                print_error("markdup", "warning, barcode regex match error \"%s\" on %s.\n", warn_msg, qname);
+            }
+        }
+    }
+
+    if ((*warnings == BMD_WARNING_MAX) && (incoming_warnings != *warnings)) {
+        print_error("markdup", "warning, %ld barcode read warnings.  New warnings will not be reported.\n",
+                        *warnings);
+    }
+
+
+    key->single        = 1;
+    key->this_ref      = this_ref;
+    key->this_coord    = this_coord;
+    key->orientation   = orientation;
+    key->barcode       = barcode;
+    key->read_group    = rg_num;
+}
+
+
+/* Add the duplicate name to a hash if it does not exist. */
+
+static int add_duplicate(khash_t(duplicates) *d_hash, bam1_t *dupe, char *orig_name, char type, int group) {
+    khiter_t d;
+    int ret;
+
+    d = kh_get(duplicates, d_hash, bam_get_qname(dupe));
+
+    if (d == kh_end(d_hash)) {
+        char *name = strdup(bam_get_qname(dupe));
+        if (name) {
+            d = kh_put(duplicates, d_hash, name, &ret);
+        } else {
+            ret = -1;
+        }
+
+        if (ret >= 0) {
+            if (orig_name) {
+                if (ret == 0) {
+                    // replace old name
+                    free(kh_value(d_hash, d).name);
+                    free(name);
+                }
+
+                kh_value(d_hash, d).name = strdup(orig_name);
+
+                if (kh_value(d_hash, d).name == NULL) {
+                    print_error("markdup", "error, unable to allocate memory for duplicate original name.\n");
+                    return 1;
+                }
+            } else {
+                kh_value(d_hash, d).name = NULL;
+            }
+
+            kh_value(d_hash, d).type = type;
+            kh_value(d_hash, d).read_group = group;
+        } else {
+            print_error("markdup", "error, unable to store supplementary duplicates.\n");
+            free(name);
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+
+/* Get coordinates from the standard Illumina style read names.
+   Returned values are of the x and y coordinates and a section of
+   the read name to test (t) for string equality e.g. lane and tile part. */
+
+static int get_coordinates_colons(md_param_t *param, const char *qname, int *t_beg, int *t_end, long *x_coord, long *y_coord, long *warnings) {
+    int sep = 0;
+    int pos = 0;
+    int xpos = 0, ypos = 0;
+    char *end;
+
+    while (qname[pos]) {
+        if (qname[pos] == ':') {
+            sep++;
+
+            if (sep == 2) {
+                xpos = pos + 1;
+            } else if (sep == 3) {
+                ypos = pos + 1;
+            } else if (sep == 4) { // HiSeq style names
+                xpos = ypos;
+                ypos = pos + 1;
+            } else if (sep == 5) { // Newer Illumina format
+                xpos = pos + 1;
+            } else if (sep == 6) {
+                ypos = pos + 1;
+            }
+        }
+
+        pos++;
+    }
+
+    /* The most current Illumina read format at time of writing is:
+       @machine:run:flowcell:lane:tile:x:y:UMI or
+       @machine:run:flowcell:lane:tile:x:y
+
+       Counting the separating colons gives us a quick format check.
+       Older name formats have fewer elements.
+    */
+
+    if (!(sep == 3 || sep == 4 || sep == 6 || sep == 7)) {
+        (*warnings)++;
+
+        if (*warnings <= BMD_WARNING_MAX) {
+            print_error("markdup", "warning, cannot decipher read name %s for optical duplicate marking.\n", qname);
+        }
+
+        return 1;
+    } else {
+        *x_coord = strtol(qname + xpos, &end, 10);
+
+        if ((qname + xpos) == end) {
+            (*warnings)++;
+
+            if (*warnings <= BMD_WARNING_MAX) {
+                print_error("markdup", "warning, cannot decipher x coordinate in %s .\n", qname);
+            }
+
+            return 1;
+        }
+
+        *y_coord = strtol(qname + ypos, &end, 10);
+
+        if ((qname + ypos) == end) {
+            (*warnings)++;
+
+            if (*warnings <= BMD_WARNING_MAX) {
+                print_error("markdup", "warning, cannot decipher y coordinate in %s .\n", qname);
+            }
+
+            return 1;
+        }
+
+        *t_beg = 0;
+        *t_end = xpos;
+    }
+
+    return 0;
+}
+
+/* Get the coordinates from the read name.
+   Returned values are of the x and y coordinates and an optional section of
+   the read name to test (t) for string equality e.g. lane and tile part. */
+
+static inline int get_coordinates_regex(md_param_t *param, const char *qname, int *t_beg, int *t_end, long *x_coord, long *y_coord, long *warnings) {
+    regmatch_t matches[5];
+    size_t max_matches = 5;
+    int xpos, ypos, xend, yend, xlen, ylen;
+    char coord[255];
+    char *end;
+
+    if (!param->rgx_t)
+        max_matches = 4;
+
+    if (regexec(param->rgx, qname, max_matches, matches, 0))
+        return -1;
+
+    xpos = matches[param->rgx_x].rm_so;
+    ypos = matches[param->rgx_y].rm_so;
+
+    if (param->rgx_t) {
+        *t_beg = matches[param->rgx_t].rm_so;
+        *t_end = matches[param->rgx_t].rm_eo;
+    } else {
+        *t_beg = *t_end = 0;
+    }
+
+    if (xpos == -1 || ypos == -1 || *t_beg == -1)
+        return -1;
+
+    xend = matches[param->rgx_x].rm_eo;
+    yend = matches[param->rgx_y].rm_eo;
+
+    if ((xlen = xend - xpos) > 254) {
+        (*warnings)++;
+
+        if (*warnings <= BMD_WARNING_MAX) {
+            print_error("markdup", "warning, x coordinate string longer than allowed qname length in %s (%d long).\n", qname, xlen);
+        }
+
+        return 1;
+    }
+
+    strncpy(coord, qname + xpos, xlen);
+    coord[xlen] = '\0';
+    *x_coord = strtol(coord, &end, 10);
+
+    if (coord == end) {
+        (*warnings)++;
+
+        if (*warnings <= BMD_WARNING_MAX) {
+            print_error("markdup", "warning, cannot decipher x coordinate in %s (%s).\n", qname, coord);
+        }
+
+        return 1;
+    }
+
+    if ((ylen = yend - ypos) > 254) {
+        (*warnings)++;
+
+        if (*warnings <= BMD_WARNING_MAX) {
+            print_error("markdup", "warning, y coordinate string longer than allowed qname length in %s (%d long).\n", qname, ylen);
+        }
+
+        return 1;
+    }
+
+    strncpy(coord, qname + ypos, ylen);
+    coord[ylen] = '\0';
+    *y_coord = strtol(coord, &end, 10);
+
+    if (coord == end) {
+        (*warnings)++;
+
+        if (*warnings <= BMD_WARNING_MAX) {
+            print_error("markdup", "warning, cannot decipher y coordinate in %s (%s).\n", qname, coord);
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+
+static int get_coordinates(md_param_t *param, const char *name, int *t_beg, int *t_end, long *x_coord, long *y_coord, long *warnings) {
+    int ret = 1;
+
+    if (param->rgx == NULL) {
+        ret = get_coordinates_colons(param, name, t_beg, t_end, x_coord, y_coord, warnings);
+    } else {
+        ret = get_coordinates_regex(param, name, t_beg, t_end, x_coord, y_coord, warnings);
+    }
+
+    return ret;
+}
+
+
+/* Using the coordinates from the read name, see whether the duplicated read is
+   close enough (set by max_dist) to the original to be counted as optical.*/
+
+static int is_optical_duplicate(md_param_t *param, bam1_t *ori, bam1_t *dup, long max_dist, long *warnings) {
+    int ret = 0;
+    char *original, *duplicate;
+    long ox, oy, dx, dy;
+    int o_beg = 0, o_end = 0, d_beg = 0, d_end = 0;
+
+    original  = bam_get_qname(ori);
+    duplicate = bam_get_qname(dup);
+
+    if (get_coordinates(param, original, &o_beg, &o_end, &ox, &oy, warnings)) {
+        return ret;
+    }
+
+    if (get_coordinates(param, duplicate, &d_beg, &d_end, &dx, &dy, warnings)) {
+        return ret;
+    }
+
+    if (strncmp(original + o_beg, duplicate + d_beg, o_end - o_beg) == 0) {
+        long xdiff, ydiff;
+
+        if (ox > dx) {
+            xdiff = ox - dx;
+        } else {
+            xdiff = dx - ox;
+        }
+
+        if (xdiff <= max_dist) {
+            // still might be optical
+
+            if (oy > dy) {
+                ydiff = oy - dy;
+            } else {
+                ydiff = dy - oy;
+            }
+
+            if (ydiff <= max_dist) ret = 1;
+        }
+    }
+
+    return ret;
+}
+
+
+/* Using the coordinates from the Illumina read name, see whether the duplicated read is
+   close enough (set by max_dist) to the original to be counted as optical.
+
+   This function needs the values from the first read to be already calculated. */
+
+static int optical_duplicate_partial(md_param_t *param, const char *name, const int o_beg, const int o_end, const long ox, const long oy, bam1_t *dup, check_t *c, long max_dist, long *warnings) {
+    int ret = 0;
+    char *duplicate;
+    int d_beg = 0, d_end = 0;
+    long dx, dy;
+
+    duplicate = bam_get_qname(dup);
+
+    if (get_coordinates(param, duplicate, &d_beg, &d_end, &dx, &dy, warnings)) {
+        return ret;
+    }
+
+    if (strncmp(name + o_beg, duplicate + d_beg, o_end - o_beg) == 0) {
+        // the initial parts match, look at the numbers
+        long xdiff, ydiff;
+
+        if (ox > dx) {
+            xdiff = ox - dx;
+        } else {
+            xdiff = dx - ox;
+        }
+
+        if (xdiff <= max_dist) {
+            // still might be optical
+
+            if (oy > dy) {
+                ydiff = oy - dy;
+            } else {
+                ydiff = dy - oy;
+            }
+
+            if (ydiff <= max_dist) ret = 1;
+        }
+    }
+
+    c->x = dx;
+    c->y = dy;
+    c->beg = d_beg;
+    c->end = d_end;
+
+    return ret;
+}
+
+
+/* Mark the read as a duplicate and update the duplicate hash (if needed) */
+static int mark_duplicates(md_param_t *param, khash_t(duplicates) *dup_hash, bam1_t *ori, bam1_t *dup,
+                           int read_group, long *optical, long *warn) {
+    char dup_type = 0;
+    long incoming_warnings = *warn;
+
+    dup->core.flag |= BAM_FDUP;
+
+    if (param->tag) {
+        if (bam_aux_update_str(dup, "do", strlen(bam_get_qname(ori)) + 1, bam_get_qname(ori))) {
+            print_error("markdup", "error, unable to append 'do' tag.\n");
+            return -1;
+        }
+    }
+
+    if (param->opt_dist) { // mark optical duplicates
+        if (is_optical_duplicate(param, ori, dup, param->opt_dist, warn)) {
+            bam_aux_update_str(dup, "dt", 3, "SQ");
+            dup_type = 'O';
+            (*optical)++;
+        } else {
+            // not an optical duplicate
+            bam_aux_update_str(dup, "dt", 3, "LB");
+        }
+    }
+
+    if ((*warn == BMD_WARNING_MAX) && (incoming_warnings != *warn)) {
+        print_error("markdup", "warning, %ld decipher read name warnings.  New warnings will not be reported.\n",
+                        *warn);
+    }
+
+    if (param->supp) {
+        if (bam_aux_get(dup, "SA") || (dup->core.flag & BAM_FMUNMAP) || bam_aux_get(dup, "XA")) {
+            char *original = NULL;
+
+            if (param->tag) {
+                original = bam_get_qname(ori);
+            }
+
+            if (add_duplicate(dup_hash, dup, original, dup_type, read_group))
+                return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+/* If the duplicate type has changed to optical then retag and duplicate hash. */
+static inline int optical_retag(md_param_t *param, khash_t(duplicates) *dup_hash, bam1_t *b, int paired, stats_block_t *stats) {
+    int ret = 0;
+
+    if (bam_aux_update_str(b, "dt", 3, "SQ")) {
+        print_error("markdup", "error, unable to update 'dt' tag.\n");
+        ret = -1;
+    }
+
+    if (paired) {
+        stats->optical++;
+    } else {
+        stats->single_optical++;
+    }
+
+    if (param->supp) {
+        // Change the duplicate type
+
+        if (bam_aux_get(b, "SA") || (b->core.flag & BAM_FMUNMAP)
+            || bam_aux_get(b, "XA")) {
+            khiter_t d;
+
+            d = kh_get(duplicates, dup_hash, bam_get_qname(b));
+
+            if (d == kh_end(dup_hash)) {
+                // error, name should already be in dup hash
+                print_error("markdup", "error, duplicate name %s not found in hash.\n",
+                    bam_get_qname(b));
+                ret = -1;
+            } else {
+                kh_value(dup_hash, d).type = 'O';
+            }
+        }
+    }
+
+    return ret;
+}
+
+
+/* Check all duplicates of the highest quality read (the "original") for consistancy.  Also
+   pre-calculate any values for use in check_duplicate_chain later.
+   Returns 0 on success, >0 on coordinate reading error (program can continue) or
+   <0 on an error (program should not continue. */
+static int check_chain_against_original(md_param_t *param, khash_t(duplicates) *dup_hash, read_queue_t *ori,
+             check_list_t *list, long *warn, stats_block_t *stats) {
+
+    int ret = 0, coord_fail = 0;
+    char *ori_name = bam_get_qname(ori->b);
+    read_queue_t *current = ori->duplicate;
+    int t_beg = 0, t_end = 0;
+    long x, y;
+
+    if (param->opt_dist) {
+        coord_fail = get_coordinates(param, ori_name, &t_beg, &t_end, &x, &y, warn);
+    }
+
+    list->length = 0;
+
+    while (current) {
+        check_t *c;
+
+        if (list->length >= list->size) {
+            check_t *tmp;
+
+            list->size *= 2;
+
+            if (!(tmp = realloc(list->c, list->size * sizeof(check_t)))) {
+                print_error("markdup", "error, Unable to expand optical check list.\n");
+                return -1;
+            }
+
+            list->c = tmp;
+        }
+
+        c = &list->c[list->length];
+
+        c->b = current->b;
+        c->x = -1;
+        c->y = -1;
+        c->opt = 0;
+        c->score = 0;
+        c->mate_score = 0;
+        current->dup_checked = 1;
+
+        if (param->tag) {
+            uint8_t *data;
+
+            // at this stage all duplicates should have a do tag
+            if ((data = bam_aux_get(current->b, "do")) != NULL) {
+                // see if we need to change the tag
+                char *old_name = bam_aux2Z(data);
+
+                if (old_name) {
+                    if (strcmp(old_name, ori_name) != 0) {
+                        if (bam_aux_update_str(current->b, "do", strlen(ori_name) + 1, (const char *)ori_name)) {
+                            print_error("markdup", "error, unable to update 'do' tag.\n");
+                            ret =  -1;
+                            break;
+                        }
+                    }
+                } else {
+                    print_error("markdup", "error, 'do' tag has wrong type for read %s.\n", bam_get_qname(current->b));
+                    ret = -1;
+                    break;
+                }
+            }
+        }
+
+        if (param->opt_dist && !coord_fail) {
+            uint8_t *data;
+            char *dup_type;
+            int is_opt = 0;
+            int current_paired = (current->b->core.flag & BAM_FPAIRED) && !(current->b->core.flag & BAM_FMUNMAP);
+
+            if ((data = bam_aux_get(current->b, "dt"))) {
+                if ((dup_type = bam_aux2Z(data))) {
+                    if (strcmp(dup_type, "SQ") == 0) {
+                        c->opt = 1;
+                    }
+                }
+            }
+
+            // need to run this to get the duplicates x and y scores
+            is_opt = optical_duplicate_partial(param, ori_name, t_beg, t_end, x, y, current->b, c, param->opt_dist, warn);
+
+            if (!c->opt && is_opt) {
+                if (optical_retag(param, dup_hash, current->b, current_paired, stats)) {
+                    ret = -1;
+                    break;
+                }
+
+                c->opt = 1;
+            }
+
+            c->score = calc_score(current->b);
+
+            if (current_paired) {
+                if ((c->mate_score = get_mate_score(current->b)) == -1) {
+                     print_error("markdup", "error, no ms score tag. Please run samtools fixmate on file first.\n");
+                     ret = -1;
+                     break;
+                }
+            }
+        }
+
+        current = current->duplicate;
+        list->length++;
+    }
+
+    if (!ret && coord_fail)
+        ret = coord_fail;
+
+    ori->dup_checked = 1;
+
+    return ret;
+}
+
+
+static int xcoord_sort(const void *a, const void *b) {
+    check_t *ac = (check_t *) a;
+    check_t *bc = (check_t *) b;
+
+    return (ac->x - bc->x);
+}
+
+
+/* Check all the duplicates against each other to see if they are optical duplicates. */
+static int check_duplicate_chain(md_param_t *param, khash_t(duplicates) *dup_hash, check_list_t *list,
+             long *warn, stats_block_t *stats) {
+    int ret = 0;
+    size_t curr = 0;
+
+    qsort(list->c, list->length, sizeof(list->c[0]), xcoord_sort);
+
+    while (curr < list->length - 1) {
+        check_t *current = &list->c[curr];
+        size_t count = curr;
+        char *cur_name = bam_get_qname(current->b);
+        int current_paired = (current->b->core.flag & BAM_FPAIRED) && !(current->b->core.flag & BAM_FMUNMAP);
+
+        while (++count < list->length && (list->c[count].x - current->x <= param->opt_dist)) {
+            // while close enough along the x coordinate
+            check_t *chk = &list->c[count];
+
+            if (current->opt && chk->opt)
+                continue;
+
+            // if both are already optical duplicates there is no need to check again, otherwise...
+
+            long ydiff;
+
+            if (current->y > chk->y) {
+                ydiff = current->y - chk->y;
+            } else {
+                ydiff = chk->y - current->y;
+            }
+
+            if (ydiff > param->opt_dist)
+                continue;
+
+            // the number are right, check the names
+            if (strncmp(cur_name + current->beg, bam_get_qname(chk->b) + chk->beg, current->end - current->beg) != 0)
+                continue;
+
+            // optical duplicates
+            int chk_dup = 0;
+            int chk_paired = (chk->b->core.flag & BAM_FPAIRED) && !(chk->b->core.flag & BAM_FMUNMAP);
+
+            if (current_paired != chk_paired) {
+                if (!chk_paired) {
+                    // chk is single vs pair, this is a dup.
+                    chk_dup = 1;
+                }
+            } else {
+                // do it by scores
+                int64_t cur_score, chk_score;
+
+                if ((current->b->core.flag & BAM_FQCFAIL) != (chk->b->core.flag & BAM_FQCFAIL)) {
+                    if (current->b->core.flag & BAM_FQCFAIL) {
+                        cur_score = 0;
+                        chk_score = 1;
+                    } else {
+                        cur_score = 1;
+                        chk_score = 0;
+                    }
+                } else {
+                    cur_score = current->score;
+                    chk_score = chk->score;
+
+                    if (current_paired) {
+                        // they are pairs so add mate scores.
+                        chk_score += chk->mate_score;
+                        cur_score += current->mate_score;
+                    }
+                }
+
+                if (cur_score == chk_score) {
+                    if (strcmp(bam_get_qname(chk->b), cur_name) < 0) {
+                        chk_score++;
+                    } else {
+                        chk_score--;
+                    }
+                }
+
+                if (cur_score > chk_score) {
+                    chk_dup = 1;
+                }
+            }
+
+            if (chk_dup) {
+                // the duplicate is the optical duplicate
+                if (!chk->opt) { // only change if not already an optical duplicate
+                    if (optical_retag(param, dup_hash, chk->b, chk_paired, stats)) {
+                        ret = -1;
+                        goto fail;
+                    }
+
+                    chk->opt = 1;
+                }
+            } else {
+                if (!current->opt) {
+                    if (optical_retag(param, dup_hash, current->b, current_paired, stats)) {
+                        ret = -1;
+                        goto fail;
+                    }
+
+                    current->opt = 1;
+                }
+            }
+        }
+
+        curr++;
+    }
+
+ fail:
+    return ret;
+}
+
+
+/* Where there is more than one duplicate go down the list and check for optical duplicates and change
+   do tags (where used) to point to original (non-duplicate) read. */
+static int find_duplicate_chains(md_param_t *param, read_queue_t *in_read , khash_t(duplicates) *dup_hash, check_list_t *dup_list,
+                                long *warn, stats_block_t *stats) {
+    int ret = 0;
+
+    while (in_read->original) in_read = in_read->original;
+
+    // check against the original for tagging and optical duplication
+    if ((ret = check_chain_against_original(param, dup_hash, in_read, dup_list, warn, stats + in_read->read_group))) {
+        if (ret < 0) { // real error
+            ret = -1;
+        } else { // coordinate decoding error
+            ret = 0;
+        }
+    } else {
+        // check the rest of the duplicates against each other for optical duplication
+        if (param->opt_dist && check_duplicate_chain(param, dup_hash, dup_list, warn, stats + in_read->read_group)) {
+            ret = -1;
+        }
+    }
+
+    return ret;
+}
+
+
+/*
+  Function to use when estimating library size.
+
+  This is based on an approximate formula for the coverage of a set
+  obtained after sampling it a given number of times with replacement.
+
+  x = number of items in the set (the number of unique fragments in the library)
+
+  c = number of unique items (unique read pairs observed)
+
+  n = number of items samples (total number of read pairs)
+
+  c and n are known; x is unknown.
+
+  As n -> infinity, the coverage (c/x) can be given as:
+
+  c / x = 1 - exp(-n / x)  (see https://math.stackexchange.com/questions/32800)
+
+  This needs to be solved for x, so it is rearranged to put both terms on the
+  left side and estimate_library_size() finds a value of x which gives a
+  result of zero (or as close as it can get).
+ */
+static inline double coverage_equation(double x, double c, double n) {
+    return c / x - 1 + exp(-n / x);
+}
+
+
+/* estimate the library size, based on the Picard code in DuplicationMetrics.java*/
+static unsigned long estimate_library_size(unsigned long paired_reads, unsigned long paired_duplicate_reads, unsigned long optical) {
+    unsigned long estimated_size = 0;
+    unsigned long non_optical_pairs = (paired_reads - optical) / 2;
+    unsigned long unique_pairs = (paired_reads - paired_duplicate_reads) / 2;
+    unsigned long duplicate_pairs = (paired_duplicate_reads - optical) / 2;
+
+    if ((non_optical_pairs && duplicate_pairs && unique_pairs) && (non_optical_pairs > duplicate_pairs)) {
+        double m = 1;
+        double M = 100;
+        int i;
+
+        if (coverage_equation(m * (double)unique_pairs, (double)unique_pairs, (double)non_optical_pairs) < 0) {
+            print_error("markdup", "warning, unable to calculate estimated library size.\n");
+            return  estimated_size;
+        }
+
+        while (coverage_equation(M * (double)unique_pairs, (double)unique_pairs, (double)non_optical_pairs) > 0) {
+            M *= 10;
+        }
+
+        for (i = 0; i < 40; i++) {
+            double r = (m + M) / 2;
+            double u = coverage_equation(r * (double)unique_pairs, (double)unique_pairs, (double)non_optical_pairs);
+
+            if (u > 0) {
+                m = r;
+            } else if (u < 0) {
+                M = r;
+            } else {
+                break;
+            }
+        }
+
+        estimated_size = (unsigned long)(unique_pairs * (m + M) / 2);
+    } else {
+        print_error("markdup", "warning, unable to calculate estimated library size."
+                        " Read pairs %ld should be greater than duplicate pairs %ld,"
+                        " which should both be non zero.\n",
+                        non_optical_pairs, duplicate_pairs);
+    }
+
+    return estimated_size;
+}
+
+
+static void write_stats(FILE *fp, const char *title,  const char *title_con, stats_block_t *stats) {
+    unsigned long els;
+
+    els = estimate_library_size(stats->pair, stats->duplicate, stats->optical);
+
+    if (title) {
+        fprintf(fp, "%s%s\n", title, title_con);
+    }
+
+    fprintf(fp,
+            "READ: %ld\n"
+            "WRITTEN: %ld\n"
+            "EXCLUDED: %ld\n"
+            "EXAMINED: %ld\n"
+            "PAIRED: %ld\n"
+            "SINGLE: %ld\n"
+            "DUPLICATE PAIR: %ld\n"
+            "DUPLICATE SINGLE: %ld\n"
+            "DUPLICATE PAIR OPTICAL: %ld\n"
+            "DUPLICATE SINGLE OPTICAL: %ld\n"
+            "DUPLICATE NON PRIMARY: %ld\n"
+            "DUPLICATE NON PRIMARY OPTICAL: %ld\n"
+            "DUPLICATE PRIMARY TOTAL: %ld\n"
+            "DUPLICATE TOTAL: %ld\n"
+            "ESTIMATED_LIBRARY_SIZE: %ld\n", stats->reading, stats->writing, stats->excluded, stats->examined, stats->pair, stats->single,
+                            stats->duplicate, stats->single_dup, stats->optical, stats->single_optical, stats->np_duplicate, stats->np_opt_duplicate,
+                            stats->single_dup + stats->duplicate, stats->single_dup + stats->duplicate + stats->np_duplicate, els);
+}
+
+
+static void write_json_stats(FILE *fp, const char *offset, const char *group_name, stats_block_t *stats, const char *end) {
+    unsigned long  els;
+
+    els = estimate_library_size(stats->pair, stats->duplicate, stats->optical);
+
+    if (group_name) {
+        fprintf(fp, "%s\"READ GROUP\": \"%s\",\n", offset, group_name);
+    }
+
+    fprintf(fp, "%s\"READ\": %ld,\n", offset, stats->reading);
+    fprintf(fp, "%s\"WRITTEN\": %ld,\n", offset, stats->writing);
+    fprintf(fp, "%s\"EXCLUDED\": %ld,\n", offset, stats->excluded);
+    fprintf(fp, "%s\"EXAMINED\": %ld,\n", offset, stats->examined);
+    fprintf(fp, "%s\"PAIRED\": %ld,\n", offset, stats->pair);
+    fprintf(fp, "%s\"SINGLE\": %ld,\n", offset, stats->single);
+    fprintf(fp, "%s\"DUPLICATE PAIR\": %ld,\n", offset, stats->duplicate);
+    fprintf(fp, "%s\"DUPLICATE SINGLE\": %ld,\n", offset, stats->single_dup);
+    fprintf(fp, "%s\"DUPLICATE PAIR OPTICAL\": %ld,\n", offset, stats->optical);
+    fprintf(fp, "%s\"DUPLICATE SINGLE OPTICAL\": %ld,\n", offset, stats->single_optical);
+    fprintf(fp, "%s\"DUPLICATE NON PRIMARY\": %ld,\n", offset, stats->np_duplicate);
+    fprintf(fp, "%s\"DUPLICATE NON PRIMARY OPTICAL\": %ld,\n", offset, stats->np_opt_duplicate);
+    fprintf(fp, "%s\"DUPLICATE PRIMARY TOTAL\": %ld,\n", offset, stats->single_dup + stats->duplicate);
+    fprintf(fp, "%s\"DUPLICATE TOTAL\": %ld,\n", offset, stats->single_dup + stats->duplicate + stats->np_duplicate);
+    fprintf(fp, "%s\"ESTIMATED_LIBRARY_SIZE\": %ld", offset, els);
+
+    if (end) {
+        fprintf(fp, "%s", end);
+    }
+}
+
+
+/* Compare the reads near each other (coordinate sorted) and try to spot the duplicates.
+   Generally the highest quality scoring is chosen as the original and all others the duplicates.
+   The score is based on the sum of the quality values (<= 15) of the read and its mate (if any).
+   While single reads are compared to only one read of a pair, the pair will chosen as the original.
+   The comparison is done on position and orientation, see above for details.
+
+   Marking the supplementary reads of a duplicate as also duplicates takes an extra file read/write
+   step.  This is because the duplicate can occur before the primary read.*/
+
+static int bam_mark_duplicates(md_param_t *param) {
+    bam_hdr_t *header = NULL;
+    khiter_t k;
+    khash_t(reads) *pair_hash        = kh_init(reads);
+    khash_t(reads) *single_hash      = kh_init(reads);
+    klist_t(read_queue) *read_buffer = kl_init(read_queue);
+    kliter_t(read_queue) *rq;
+    khash_t(duplicates) *dup_hash    = kh_init(duplicates);
+    khash_t(read_groups) *rg_hash    = kh_init(read_groups);
+    int32_t prev_tid;
+    hts_pos_t prev_coord;
+    read_queue_t *in_read;
+    int ret;
+    stats_block_t *stats, *stat_array = NULL;
+    int num_groups = 0;
+    long opt_warnings = 0, bc_warnings = 0;
+    tmp_file_t temp;
+    char *idx_fn = NULL;
+    int exclude = 0;
+    check_list_t dup_list = {NULL, 0, 0};
+
+    if (!pair_hash || !single_hash || !read_buffer || !dup_hash || !rg_hash) {
+        print_error("markdup", "error, unable to allocate memory to initialise structures.\n");
+        goto fail;
+    }
+
+    if ((header = sam_hdr_read(param->in)) == NULL) {
+        print_error("markdup", "error reading header\n");
+        goto fail;
+    }
+
+    // accept unknown, unsorted or coordinate sort order, but error on queryname sorted.
+    // only really works on coordinate sorted files.
+    kstring_t str = KS_INITIALIZE;
+    if (!sam_hdr_find_tag_hd(header, "SO", &str) && str.s && !strcmp(str.s, "queryname")) {
+        print_error("markdup", "error, queryname sorted, must be sorted by coordinate.\n");
+        ks_free(&str);
+        goto fail;
+    }
+    ks_free(&str);
+
+    if (!param->no_pg && sam_hdr_add_pg(header, "samtools", "VN", samtools_version(),
+                        param->arg_list ? "CL" : NULL,
+                        param->arg_list ? param->arg_list : NULL,
+                        NULL) != 0) {
+        print_error("markdup", "warning, unable to add @PG line to header.\n");
+    }
+
+    if (sam_hdr_write(param->out, header) < 0) {
+        print_error("markdup", "error writing header.\n");
+        goto fail;
+    }
+    if (param->write_index) {
+        if (!(idx_fn = auto_index(param->out, param->out_fn, header)))
+            goto fail;
+    }
+
+    if (param->read_groups) {
+        num_groups = sam_hdr_count_lines(header, "RG");
+        int g_ret = 0;
+
+        if (num_groups > 0) {
+            int i;
+
+            for (i = 0; i < num_groups; i++) {
+                const char *rg_key;
+                khiter_t rg;
+
+                rg_key = sam_hdr_line_name(header, "RG", i);
+
+                if (rg_key) {
+                    rg = kh_get(read_groups, rg_hash, rg_key);
+
+                    if (rg == kh_end(rg_hash)) { // new entry
+                        rg = kh_put(read_groups, rg_hash, rg_key, &g_ret);
+
+                        if (g_ret > 0) {
+                            kh_value(rg_hash, rg) = i + 1;
+                        } else {
+                            print_error("markdup", "error, unable to populate read group ids.  "
+                                     "Read groups will not be used\n");
+                            g_ret = -1;
+                            break;
+                        }
+                    } else {
+                        print_error("markdup", "error, duplicate read group ids %s."
+                                  "Read groups will not be used\n", rg_key);
+                        g_ret = -1;
+                        break;
+                    }
+                } else {
+                    print_error("markdup", "error, Unable to retrieve read group at position %d."
+                              "Read groups will not be used\n", i);
+                    g_ret = -1;
+                    break;
+                }
+            }
+        } else {
+            print_error("markdup", "error, no read groups found.\n");
+            g_ret = -1;
+        }
+
+        if (g_ret < 0) {
+            print_error("markdup", "error, read groups will not be used.\n");
+            param->read_groups = 0;
+            num_groups = 0;
+        }
+    }
+
+    // stat_array[0] will be for ungrouped reads
+    stat_array = calloc(num_groups + 1, sizeof(stats_block_t));
+
+    if (stat_array == NULL) {
+        print_error("markdup", "error, unable to allocate memory for stats.\n");
+        goto fail;
+    }
+
+    // used for coordinate order checks
+    prev_tid = prev_coord = 0;
+
+    // get the buffer going
+    in_read = kl_pushp(read_queue, read_buffer);
+    if (!in_read) {
+        print_error("markdup", "error, unable to allocate memory to hold reads.\n");
+        goto fail;
+    }
+
+    // handling supplementary reads needs a temporary file
+    if (param->supp) {
+        if (tmp_file_open_write(&temp, param->prefix, 1)) {
+            print_error("markdup", "error, unable to open tmp file %s.\n", param->prefix);
+            goto fail;
+        }
+    }
+
+    if ((in_read->b = bam_init1()) == NULL) {
+        print_error("markdup", "error, unable to allocate memory for alignment.\n");
+        goto fail;
+    }
+
+    if (param->check_chain && !(param->tag || param->opt_dist))
+        param->check_chain = 0;
+
+    if (param->check_chain) {
+        dup_list.size = 128;
+        dup_list.c = NULL;
+
+        if ((dup_list.c = malloc(dup_list.size * sizeof(check_t))) == NULL) {
+            print_error("markdup", "error, unable to allocate memory for dup_list.\n");
+            goto fail;
+        }
+    }
+
+    while ((ret = sam_read1(param->in, header, in_read->b)) >= 0) {
+
+        // do some basic coordinate order checks
+        if (in_read->b->core.tid >= 0) { // -1 for unmapped reads
+            if (in_read->b->core.tid < prev_tid ||
+               ((in_read->b->core.tid == prev_tid) && (in_read->b->core.pos < prev_coord))) {
+                print_error("markdup", "error, not in coordinate sorted order.\n");
+                goto fail;
+            }
+        }
+
+        prev_coord = in_read->pos = in_read->b->core.pos;
+        prev_tid   =  in_read->b->core.tid;
+        in_read->pair_key.single   = 1;
+        in_read->single_key.single = 0;
+        in_read->duplicate = NULL;
+        in_read->original = NULL;
+        in_read->dup_checked = 0;
+        in_read->read_group = 0;
+        in_read->dc = 1;
+
+        if (param->read_groups) {
+            uint8_t *data;
+            char *rg;
+
+            if ((data = bam_aux_get(in_read->b, "RG"))) {
+                if ((rg = bam_aux2Z(data))) {
+                    khiter_t r;
+
+                    r = kh_get(read_groups, rg_hash, rg);
+
+                    if (r != kh_end(rg_hash)) {
+                        in_read->read_group = kh_value(rg_hash, r);
+                    }
+                }
+            }
+        }
+
+        stats = stat_array + in_read->read_group;
+
+        stats->reading++;
+
+        if (param->clear && (in_read->b->core.flag & BAM_FDUP)) {
+            uint8_t *data;
+
+            in_read->b->core.flag ^= BAM_FDUP;
+
+            if ((data = bam_aux_get(in_read->b, "dt")) != NULL) {
+                bam_aux_del(in_read->b, data);
+            }
+
+            if ((data = bam_aux_get(in_read->b, "do")) != NULL) {
+                bam_aux_del(in_read->b, data);
+            }
+        }
+
+        if (param->include_fails) {
+            exclude |= (BAM_FSECONDARY | BAM_FSUPPLEMENTARY | BAM_FUNMAP);
+        } else {
+            exclude |= (BAM_FSECONDARY | BAM_FSUPPLEMENTARY | BAM_FUNMAP | BAM_FQCFAIL);
+        }
+
+        // read must not be secondary, supplementary, unmapped or (possibly) failed QC
+        if (!(in_read->b->core.flag & exclude)) {
+            stats->examined++;
+
+
+            // look at the pairs first
+            if ((in_read->b->core.flag & BAM_FPAIRED) && !(in_read->b->core.flag & BAM_FMUNMAP)) {
+                int ret, mate_tmp;
+                key_data_t pair_key;
+                key_data_t single_key;
+                in_hash_t *bp;
+
+                if (make_pair_key(param, &pair_key, in_read->b, in_read->read_group, &bc_warnings)) {
+                    print_error("markdup", "error, unable to assign pair hash key.\n");
+                    goto fail;
+                }
+
+                make_single_key(param, &single_key, in_read->b, in_read->read_group, &bc_warnings);
+
+                stats->pair++;
+                in_read->pos = single_key.this_coord; // cigar/orientation modified pos
+
+                // put in singles hash for checking against non paired reads
+                k = kh_put(reads, single_hash, single_key, &ret);
+
+                if (ret > 0) { // new
+                    // add to single duplicate hash
+                    bp = &kh_val(single_hash, k);
+                    bp->p = in_read;
+                    in_read->single_key = single_key;
+                } else if (ret == 0) { // exists
+                    // look at singles only for duplication marking
+                    bp = &kh_val(single_hash, k);
+
+                    if (!(bp->p->b->core.flag & BAM_FPAIRED) || (bp->p->b->core.flag & BAM_FMUNMAP)) {
+                       // singleton will always be marked duplicate even if
+                       // scores more than one read of the pair
+                        bam1_t *dup = bp->p->b;
+
+                        if (param->check_chain) {
+                            in_read->duplicate = bp->p;
+                            bp->p->original = in_read;
+                        }
+
+                        bp->p = in_read;
+                        bp->p->dc += 1;
+
+                        if (mark_duplicates(param, dup_hash, bp->p->b, dup, in_read->read_group, &stats->single_optical, &opt_warnings))
+                            goto fail;
+
+                        stats->single_dup++;
+                    }
+                } else {
+                    print_error("markdup", "error, single hashing failure for paired read.\n");
+                    goto fail;
+                }
+
+                // now do the pair
+                k = kh_put(reads, pair_hash, pair_key, &ret);
+
+                if (ret > 0) { // new
+                    // add to the pair hash
+                    bp = &kh_val(pair_hash, k);
+                    bp->p = in_read;
+                    in_read->pair_key = pair_key;
+                } else if (ret == 0) {
+                    int64_t old_score, new_score, tie_add = 0;
+                    bam1_t *dup = NULL;
+
+                    bp = &kh_val(pair_hash, k);
+
+                    if ((bp->p->b->core.flag & BAM_FQCFAIL) != (in_read->b->core.flag & BAM_FQCFAIL)) {
+                        if (bp->p->b->core.flag & BAM_FQCFAIL) {
+                            old_score = 0;
+                            new_score = 1;
+                        } else {
+                            old_score = 1;
+                            new_score = 0;
+                        }
+                    } else {
+                        if ((mate_tmp = get_mate_score(bp->p->b)) == -1) {
+                            print_error("markdup", "error, no ms score tag. Please run samtools fixmate on file first.\n");
+                            goto fail;
+                        } else {
+                            old_score = calc_score(bp->p->b) + mate_tmp;
+                        }
+
+                        if ((mate_tmp = get_mate_score(in_read->b)) == -1) {
+                            print_error("markdup", "error, no ms score tag. Please run samtools fixmate on file first.\n");
+                            goto fail;
+                        } else {
+                            new_score = calc_score(in_read->b) + mate_tmp;
+                        }
+                    }
+
+                    // choose the highest score as the original
+                    // and add it to the pair hash, mark the other as duplicate
+
+                    if (new_score == old_score) {
+                        if (strcmp(bam_get_qname(in_read->b), bam_get_qname(bp->p->b)) < 0) {
+                            tie_add = 1;
+                        } else {
+                            tie_add = -1;
+                        }
+                    }
+
+                    if (new_score + tie_add > old_score) { // swap reads
+                        dup = bp->p->b;
+                        in_read->dc += bp->p->dc;
+
+                        if (param->check_chain) {
+
+                            if (in_read->duplicate) {
+                                read_queue_t *current = in_read->duplicate;
+
+                                while (current->duplicate) {
+                                    current = current->duplicate;
+                                }
+
+                                current->duplicate = bp->p;
+                            } else {
+                                in_read->duplicate = bp->p;
+                            }
+
+                            bp->p->original = in_read;
+                        }
+
+                        bp->p = in_read;
+                    } else {
+                        if (param->check_chain) {
+                            if (bp->p->duplicate) {
+                                if (in_read->duplicate) {
+                                    read_queue_t *current = bp->p->duplicate;
+
+                                    while (current->duplicate) {
+                                        current = current->duplicate;
+                                    }
+
+                                    current->duplicate = in_read->duplicate;
+                                }
+
+                                in_read->duplicate = bp->p->duplicate;
+                            }
+
+                            bp->p->duplicate = in_read;
+                            in_read->original = bp->p;
+                        }
+
+                        dup = in_read->b;
+                        bp->p->dc += 1;
+                    }
+
+                    if (mark_duplicates(param, dup_hash, bp->p->b, dup, in_read->read_group, &stats->optical, &opt_warnings))
+                        goto fail;
+
+                    stats->duplicate++;
+                } else {
+                    print_error("markdup", "error, pair hashing failure.\n");
+                    goto fail;
+                }
+            } else { // do the single (or effectively single) reads
+                int ret;
+                key_data_t single_key;
+                in_hash_t *bp;
+
+                make_single_key(param, &single_key, in_read->b, in_read->read_group, &bc_warnings);
+
+                stats->single++;
+                in_read->pos = single_key.this_coord; // cigar/orientation modified pos
+
+                k = kh_put(reads, single_hash, single_key, &ret);
+
+                if (ret > 0) { // new
+                    bp = &kh_val(single_hash, k);
+                    bp->p = in_read;
+                    in_read->single_key = single_key;
+                } else if (ret == 0) { // exists
+                    bp = &kh_val(single_hash, k);
+
+                    if ((bp->p->b->core.flag & BAM_FPAIRED) && !(bp->p->b->core.flag & BAM_FMUNMAP)) {
+                        // if matched against one of a pair just mark as duplicate
+
+                        if (param->check_chain) {
+                            if (bp->p->duplicate) {
+                                in_read->duplicate = bp->p->duplicate;
+                            }
+
+                            bp->p->duplicate = in_read;
+                            in_read->original = bp->p;
+                        }
+
+                        bp->p->dc += 1;
+
+                        if (mark_duplicates(param, dup_hash, bp->p->b, in_read->b, in_read->read_group, &stats->single_optical, &opt_warnings))
+                            goto fail;
+
+                    } else {
+                        int64_t old_score, new_score;
+                        bam1_t *dup = NULL;
+
+                        old_score = calc_score(bp->p->b);
+                        new_score = calc_score(in_read->b);
+
+                        // choose the highest score as the original, add it
+                        // to the single hash and mark the other as duplicate
+                        if (new_score > old_score) { // swap reads
+                            dup = bp->p->b;
+                            in_read->dc += bp->p->dc;
+
+                            if (param->check_chain) {
+                                in_read->duplicate = bp->p;
+                                bp->p->original = in_read;
+                            }
+
+                            bp->p = in_read;
+                        } else {
+                            if (param->check_chain) {
+                                if (bp->p->duplicate) {
+                                    in_read->duplicate = bp->p->duplicate;
+                                }
+
+                                bp->p->duplicate = in_read;
+                                in_read->original = bp->p;
+                            }
+
+                            bp->p->dc += 1;
+                            dup = in_read->b;
+                        }
+
+                        if (mark_duplicates(param, dup_hash, bp->p->b, dup, in_read->read_group, &stats->single_optical, &opt_warnings))
+                            goto fail;
+                    }
+
+                    stats->single_dup++;
+                } else {
+                    print_error("markdup", "error, single hashing failure for single read.\n");
+                    goto fail;
+                }
+            }
+        } else {
+            stats->excluded++;
+        }
+
+        // loop through the stored reads and write out those we
+        // no longer need
+        rq = kl_begin(read_buffer);
+        while (rq != kl_end(read_buffer)) {
+            in_read = &kl_val(rq);
+
+            /* keep a moving window of reads based on coordinates and max read length.  Any unaligned reads
+               should just be written as they cannot be matched as duplicates. */
+            if (in_read->pos + param->max_length > prev_coord && in_read->b->core.tid == prev_tid && (prev_tid != -1 || prev_coord != -1)) {
+                break;
+            }
+
+            if (param->check_chain && !in_read->dup_checked && (in_read->original || in_read->duplicate)) {
+                if (find_duplicate_chains(param, in_read, dup_hash, &dup_list, &opt_warnings, stat_array)) {
+                    print_error("markdup", "error, duplicate checking failed.\n");
+                    goto fail;
+                }
+            }
+
+            if (!param->remove_dups || !(in_read->b->core.flag & BAM_FDUP)) {
+                if (param->dc && !(in_read->b->core.flag & BAM_FDUP)) {
+                    bam_aux_update_int(in_read->b, "dc", in_read->dc);
+                }
+                if (param->supp) {
+                    if (tmp_file_write(&temp, in_read->b)) {
+                        print_error("markdup", "error, writing temp output failed.\n");
+                        goto fail;
+                    }
+                } else {
+                    if (sam_write1(param->out, header, in_read->b) < 0) {
+                        print_error("markdup", "error, writing output failed.\n");
+                        goto fail;
+                    }
+                }
+
+                stat_array[in_read->read_group].writing++;
+            }
+
+            // remove from hash
+            if (in_read->pair_key.single == 0) {
+                k = kh_get(reads, pair_hash, in_read->pair_key);
+                kh_del(reads, pair_hash, k);
+            }
+
+            if (in_read->single_key.single == 1) {
+                k = kh_get(reads, single_hash, in_read->single_key);
+                kh_del(reads, single_hash, k);
+            }
+
+            kl_shift(read_queue, read_buffer, NULL);
+            bam_destroy1(in_read->b);
+            rq = kl_begin(read_buffer);
+        }
+
+        // set the next one up for reading
+        in_read = kl_pushp(read_queue, read_buffer);
+        if (!in_read) {
+            print_error("markdup", "error, unable to allocate memory for read in queue.\n");
+            goto fail;
+        }
+
+        if ((in_read->b = bam_init1()) == NULL) {
+            print_error("markdup", "error, unable to allocate memory for alignment.\n");
+            goto fail;
+        }
+    }
+
+    if (ret < -1) {
+        print_error("markdup", "error, truncated input file.\n");
+        goto fail;
+    }
+
+    // write out the end of the list
+    rq = kl_begin(read_buffer);
+    while (rq != kl_end(read_buffer)) {
+        in_read = &kl_val(rq);
+
+        if (bam_get_qname(in_read->b)) { // last entry will be blank
+            if (param->check_chain && !in_read->dup_checked && (in_read->original || in_read->duplicate)) {
+                if (find_duplicate_chains(param, in_read, dup_hash, &dup_list, &opt_warnings, stat_array)) {
+                    print_error("markdup", "error, duplicate checking failed.\n");
+                    goto fail;
+                }
+            }
+
+            if (!param->remove_dups || !(in_read->b->core.flag & BAM_FDUP)) {
+                if (param->dc && !(in_read->b->core.flag & BAM_FDUP)) {
+                    bam_aux_update_int(in_read->b, "dc",  in_read->dc);
+                }
+
+                if (param->supp) {
+                    if (tmp_file_write(&temp, in_read->b)) {
+                        print_error("markdup", "error, writing temp output failed on final write.\n");
+                        goto fail;
+                    }
+                } else {
+                    if (param->dc && !(in_read->b->core.flag & BAM_FDUP)) {
+                        bam_aux_update_int(in_read->b, "dc", in_read->dc);
+                    }
+
+                    if (sam_write1(param->out, header, in_read->b) < 0) {
+                        print_error("markdup", "error, writing output failed on final write.\n");
+                        goto fail;
+                    }
+                }
+
+                stat_array[in_read->read_group].writing++;
+            }
+        }
+
+        kl_shift(read_queue, read_buffer, NULL);
+        bam_destroy1(in_read->b);
+        rq = kl_begin(read_buffer);
+    }
+
+    if (param->supp) {
+        bam1_t *b;
+
+        if (tmp_file_end_write(&temp)) {
+            print_error("markdup", "error, unable to end tmp writing.\n");
+            goto fail;
+        }
+
+        // read data from temp file and mark duplicate supplementary alignments
+
+        if (tmp_file_begin_read(&temp)) {
+            goto fail;
+        }
+
+        b = bam_init1();
+
+        while ((ret = tmp_file_read(&temp, b)) > 0) {
+
+            if ((b->core.flag & BAM_FSUPPLEMENTARY) || (b->core.flag & BAM_FUNMAP) || (b->core.flag & BAM_FSECONDARY)) {
+
+                k = kh_get(duplicates, dup_hash, bam_get_qname(b));
+
+                if (k != kh_end(dup_hash)) {
+
+                    b->core.flag  |= BAM_FDUP;
+                    stat_array[kh_val(dup_hash, k).read_group].np_duplicate++;
+
+                    if (param->tag && kh_val(dup_hash, k).name) {
+                        if (bam_aux_update_str(b, "do", strlen(kh_val(dup_hash, k).name) + 1, (char*)kh_val(dup_hash, k).name)) {
+                            print_error("markdup", "error, unable to append supplementary 'do' tag.\n");
+                            goto fail;
+                        }
+                    }
+
+                    if (param->opt_dist) {
+                        if (kh_val(dup_hash, k).type) {
+                            bam_aux_update_str(b, "dt", 3, "SQ");
+                            stat_array[kh_val(dup_hash, k).read_group].np_opt_duplicate++;
+                        } else {
+                            bam_aux_update_str(b, "dt", 3, "LB");
+                        }
+                    }
+                }
+            }
+
+            if (!param->remove_dups || !(b->core.flag & BAM_FDUP)) {
+                if (param->dc && (b->core.flag & BAM_FDUP)) {
+                    uint8_t* data = bam_aux_get(b, "dc");
+                    if(data) bam_aux_del(b, data);
+                }
+                if (sam_write1(param->out, header, b) < 0) {
+                    print_error("markdup", "error, writing final output failed.\n");
+                    goto fail;
+                }
+            }
+        }
+
+        if (ret == -1) {
+            print_error("markdup", "error, failed to read tmp file.\n");
+            goto fail;
+        }
+
+        for (k = kh_begin(dup_hash); k != kh_end(dup_hash); ++k) {
+            if (kh_exist(dup_hash, k)) {
+                free(kh_val(dup_hash, k).name);
+                free((char *)kh_key(dup_hash, k));
+                kh_key(dup_hash, k) = NULL;
+            }
+        }
+
+        tmp_file_destroy(&temp);
+        bam_destroy1(b);
+    }
+
+    if (opt_warnings) {
+        print_error("markdup", "warning, number of failed attempts to get coordinates from read names = %ld\n",
+                        opt_warnings);
+    }
+
+    if (bc_warnings) {
+        print_error("markdup", "warning, number of failed attempts to get barcodes = %ld\n", bc_warnings);
+    }
+
+    if (param->do_stats) {
+        FILE *fp;
+        int file_open = 0;
+        stats_block_t total;
+        int i;
+
+        if (param->stats_file) {
+            if (NULL == (fp = fopen(param->stats_file, "w"))) {
+                print_error("markdup", "warning, cannot write stats to %s.\n", param->stats_file);
+                fp = stderr;
+            } else {
+                file_open = 1;
+            }
+        } else {
+            fp = stderr;
+        }
+
+        total = stat_array[0];
+
+        if (param->read_groups) {
+            for (i = 1; i <= num_groups; i++) {
+                total.reading += stat_array[i].reading;
+                total.writing += stat_array[i].writing;
+                total.excluded += stat_array[i].excluded;
+                total.duplicate += stat_array[i].duplicate;
+                total.single += stat_array[i].single;
+                total.pair += stat_array[i].pair;
+                total.single_dup += stat_array[i].single_dup;
+                total.examined += stat_array[i].examined;
+                total.optical += stat_array[i].optical;
+                total.single_optical += stat_array[i].single_optical;
+                total.np_duplicate += stat_array[i].np_duplicate;
+                total.np_opt_duplicate += stat_array[i].np_opt_duplicate;
+            }
+        }
+
+        if (!param->json) {
+            write_stats(fp, "COMMAND: ", param->arg_list, &total);
+            fprintf(fp, "\n");
+
+            if (param->read_groups) {
+                if (stat_array[0].reading) {
+                    write_stats(fp, "READ GROUP: ", "ungrouped", stat_array);
+                    fprintf(fp, "\n");
+                }
+
+                for (i = 0; i < num_groups; i++) {
+                    write_stats(fp, "READ GROUP: ", sam_hdr_line_name(header, "RG", i), stat_array + i + 1);
+                    fprintf(fp, "\n");
+                }
+            }
+        } else {
+            char space4[]  = "    ";
+            char space8[]  = "        ";
+            char space12[] = "            ";
+
+            fprintf(fp, "{\n");
+            fprintf(fp, "%s\"COMMAND\": \"%s\",\n", space4, param->arg_list);
+            write_json_stats(fp, space4, NULL, &total, param->read_groups ? ",\n" : "\n");
+
+            if (param->read_groups) {
+                fprintf(fp, "%s\"READ GROUPS\": [\n", space4);
+
+                if (stat_array[0].reading) {
+                    fprintf(fp, "%s{\n", space8);
+                    write_json_stats(fp, space12, "ungrouped", stat_array, "\n");
+                    fprintf(fp, "%s},\n", space8);
+                }
+
+                for (i = 0; i < num_groups; i++) {
+                    fprintf(fp, "%s{\n", space8);
+
+                    write_json_stats(fp, space12,  sam_hdr_line_name(header, "RG", i), stat_array + i + 1, "\n");
+
+                    if (i < num_groups -1 ) {
+                        fprintf(fp, "%s},\n", space8);
+                    } else {
+                        fprintf(fp, "%s}\n", space8);
+                    }
+                }
+
+                fprintf(fp, "%s]\n", space4);
+            }
+
+            fprintf(fp, "}\n");
+        }
+
+        if (file_open) {
+            fclose(fp);
+        }
+    }
+
+    if (param->write_index) {
+        if (sam_idx_save(param->out) < 0) {
+            print_error_errno("markdup", "error, writing index failed");
+            goto fail;
+        }
+    }
+
+    if (param->check_chain && (param->tag || param->opt_dist))
+        free(dup_list.c);
+
+    free(idx_fn);
+    free(stat_array);
+    kh_destroy(reads, pair_hash);
+    kh_destroy(reads, single_hash);
+    kl_destroy(read_queue, read_buffer);
+    kh_destroy(duplicates, dup_hash);
+    kh_destroy(read_groups, rg_hash);
+    sam_hdr_destroy(header);
+
+    return 0;
+
+ fail:
+    for (rq = kl_begin(read_buffer); rq != kl_end(read_buffer); rq = kl_next(rq))
+        bam_destroy1(kl_val(rq).b);
+    kl_destroy(read_queue, read_buffer);
+
+    for (k = kh_begin(dup_hash); k != kh_end(dup_hash); ++k) {
+        if (kh_exist(dup_hash, k)) {
+            free((char *)kh_key(dup_hash, k));
+        }
+    }
+    kh_destroy(duplicates, dup_hash);
+    kh_destroy(read_groups, rg_hash);
+
+    if (param->check_chain && (param->tag || param->opt_dist))
+        free(dup_list.c);
+
+    free(idx_fn);
+    free(stat_array);
+    kh_destroy(reads, pair_hash);
+    kh_destroy(reads, single_hash);
+    sam_hdr_destroy(header);
+    return 1;
+}
+
+
+static int markdup_usage(void) {
+    fprintf(stderr, "\n");
+    fprintf(stderr, "Usage:  samtools markdup <input.bam> <output.bam>\n\n");
+    fprintf(stderr, "Option: \n");
+    fprintf(stderr, "  -r                 Remove duplicate reads\n");
+    fprintf(stderr, "  -l INT             Max read length (default 300 bases)\n");
+    fprintf(stderr, "  -S                 Mark supplementary alignments of duplicates as duplicates (slower).\n");
+    fprintf(stderr, "  -s                 Report stats.\n");
+    fprintf(stderr, "  -f NAME            Write stats to named file.  Implies -s.\n");
+    fprintf(stderr, "  --json             Output stats in JSON.  Also implies -s\n");
+    fprintf(stderr, "  -T PREFIX          Write temporary files to PREFIX.samtools.nnnn.nnnn.tmp.\n");
+    fprintf(stderr, "  -d INT             Optical distance (if set, marks with dt tag)\n");
+    fprintf(stderr, "  -c                 Clear previous duplicate settings and tags.\n");
+    fprintf(stderr, "  -m --mode TYPE     Duplicate decision method for paired reads.\n"
+                    "                     TYPE = t measure positions based on template start/end (default).\n"
+                    "                            s measure positions based on sequence start.\n");
+    fprintf(stderr, "  -u                 Output uncompressed data\n");
+    fprintf(stderr, "  --include-fails    Include quality check failed reads.\n");
+    fprintf(stderr, "  --no-PG            Do not add a PG line\n");
+    fprintf(stderr, "  --no-multi-dup     Reduced duplicates of duplicates checking.\n");
+    fprintf(stderr, "  --read-coords STR  Regex for coords from read name.\n");
+    fprintf(stderr, "  --coords-order STR Order of regex elements. txy (default).  With t being a part of\n"
+                    "                     the read names that must be equal and x/y being coordinates.\n");
+    fprintf(stderr, "  --barcode-tag STR  Use barcode a tag that duplicates much match.\n");
+    fprintf(stderr, "  --barcode-name     Use the UMI/barcode in the read name (eigth colon delimited part).\n");
+    fprintf(stderr, "  --barcode-rgx STR  Regex for barcode in the readname (alternative to --barcode-name).\n");
+    fprintf(stderr, "  --use-read-groups  Use the read group tags in duplicate matching.\n");
+    fprintf(stderr, "  -t                 Mark primary duplicates with the name of the original in a \'do\' tag."
+                                        " Mainly for information and debugging.\n");
+    fprintf(stderr, "  --duplicate-count  Record the original primary read duplication count(include itself) in a \'dc\' tag.\n");
+
+    sam_global_opt_help(stderr, "-.O..@..");
+
+    fprintf(stderr, "\nThe input file must be coordinate sorted and must have gone"
+                     " through fixmates with the mate scoring option on.\n");
+
+    return 1;
+}
+
+
+int bam_markdup(int argc, char **argv) {
+    int c, ret, bc_name = 0;
+    char wmode[4] = {'w', 0, 0, 0};
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    htsThreadPool p = {NULL, 0};
+    kstring_t tmpprefix = {0, 0, NULL};
+    struct stat st;
+    unsigned int t;
+    char *regex = NULL, *bc_regex = NULL;
+    char *regex_order = "txy";
+    md_param_t param = {NULL, NULL, NULL, 0, 300, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        1, NULL, NULL, NULL, NULL, 0, 0, 0, NULL, NULL, 0, 0, 0};
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, 0, '@'),
+        {"include-fails", no_argument, NULL, 1001},
+        {"no-PG", no_argument, NULL, 1002},
+        {"mode", required_argument, NULL, 'm'},
+        {"no-multi-dup", no_argument, NULL, 1003},
+        {"read-coords", required_argument, NULL, 1004},
+        {"coords-order", required_argument, NULL, 1005},
+        {"barcode-tag", required_argument, NULL, 1006},
+        {"barcode-name", no_argument, NULL, 1007},
+        {"barcode-rgx", required_argument, NULL, 1008},
+        {"use-read-groups", no_argument, NULL, 1009},
+        {"json", no_argument, NULL, 1010},
+        {"duplicate-count", no_argument, NULL, 1011},
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "rsl:StT:O:@:f:d:cm:u", lopts, NULL)) >= 0) {
+        switch (c) {
+            case 'r': param.remove_dups = 1; break;
+            case 'l': param.max_length = atoi(optarg); break;
+            case 's': param.do_stats = 1; break;
+            case 'T': kputs(optarg, &tmpprefix); break;
+            case 'S': param.supp = 1; break;
+            case 't': param.tag = 1; break;
+            case 'f': param.stats_file = optarg; param.do_stats = 1; break;
+            case 'd': param.opt_dist = atoi(optarg); break;
+            case 'c': param.clear = 1; break;
+            case 'm':
+                if (strcmp(optarg, "t") == 0) {
+                    param.mode = MD_MODE_TEMPLATE;
+                } else if (strcmp(optarg, "s") == 0) {
+                    param.mode = MD_MODE_SEQUENCE;
+                } else {
+                    print_error("markdup", "error, unknown mode '%s'.\n", optarg);
+                    return markdup_usage();
+                }
+
+                break;
+            case 'u': wmode[1] = '0'; break;
+            case 1001: param.include_fails = 1; break;
+            case 1002: param.no_pg = 1; break;
+            case 1003: param.check_chain = 0; break;
+            case 1004: regex = optarg; break;
+            case 1005: regex_order = optarg; break;
+            case 1006: param.barcode = optarg; break;
+            case 1007: bc_name = 1; break;
+            case 1008: bc_name = 1, bc_regex = optarg; break;
+            case 1009: param.read_groups = 1; break;
+            case 1010: param.json = 1; param.do_stats = 1; break;
+            case 1011: param.dc = 1; break;
+            default: if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+            case '?': return markdup_usage();
+        }
+    }
+
+    if (optind + 2 > argc)
+        return markdup_usage();
+
+    if (param.barcode && bc_name) {
+        print_error("markdup", "error, cannot specify --barcode-tag and "
+                        "--barcode-name (or --barcode-rgx) at same time.\n");
+        return 1;
+    }
+
+    if (param.opt_dist < 0) param.opt_dist = 0;
+    if (param.max_length < 0) param.max_length = 300;
+
+    if (regex) {
+        int result;
+
+        // set the order the elements of the regex are assigned to.
+        // x and y being coordinates, t being any other important part of the read
+        // e.g. tile and lane
+        // x and y order does not matter as long as it is consistent
+
+        if ((strncmp(regex_order, "txy", 3) == 0) || (strncmp(regex_order, "tyx", 3) == 0)) {
+            param.rgx_t = 1;
+            param.rgx_x = 2;
+            param.rgx_y = 3;
+        } else if ((strncmp(regex_order, "xyt", 3) == 0) || (strncmp(regex_order, "yxt", 3) == 0)) {
+            param.rgx_x = 1;
+            param.rgx_y = 2;
+            param.rgx_t = 3;
+        } else if ((strncmp(regex_order, "xty", 3) == 0) || (strncmp(regex_order, "ytx", 3) == 0)) {
+            param.rgx_x = 1;
+            param.rgx_t = 2;
+            param.rgx_y = 3;
+        } else if ((strncmp(regex_order, "xy", 2) == 0) || (strncmp(regex_order, "yx", 2) == 0)) {
+            param.rgx_x = 1;
+            param.rgx_y = 2;
+            param.rgx_t = 0;
+        } else {
+            print_error("markdup", "error,  could not recognise regex coordinate order \"%s\".\n", regex_order);
+            return 1;
+        }
+
+        if ((param.rgx = malloc(sizeof(regex_t))) == NULL) {
+            print_error("markdup", "error,  could not allocate memory for regex.\n");
+            return 1;
+        }
+
+        if ((result = regcomp(param.rgx, regex, REG_EXTENDED))) {
+            char err_msg[256];
+
+            regerror(result, param.rgx, err_msg, 256);
+            print_error("markdup", "error, regex fail \"%s\"\n", err_msg);
+            free(param.rgx);
+            return 1;
+        }
+    }
+
+    if (bc_name) {
+        int result;
+
+        /* From Illumina UMI documentation: "The UMI sequence is located in the
+           eighth colon-delimited field of the read name (QNAME)". */
+        char *rgx = "[0-9A-Za-z]+:[0-9A-Za-z]+:[0-9A-Za-z]+:[0-9A-Za-z]+:[0-9A-Za-z]+:[0-9A-Za-z]+:[0-9A-Za-z]+:([!-?A-~]+)";
+
+        if ((param.bc_rgx = malloc(sizeof(regex_t))) == NULL) {
+            print_error("markdup", "error,  could not allocate memory for barcode regex.\n");
+            return 1;
+        }
+
+        if (bc_regex) {
+            rgx = bc_regex;
+        }
+
+        if ((result = regcomp(param.bc_rgx, rgx, REG_EXTENDED))) {
+            char err_msg[256];
+
+            regerror(result, param.bc_rgx, err_msg, 256);
+            print_error("markdup", "error, barcode regex fail \"%s\"\n", err_msg);
+            free(param.bc_rgx);
+            return 1;
+        }
+    }
+
+    param.in = sam_open_format(argv[optind], "r", &ga.in);
+
+    if (!param.in) {
+        print_error_errno("markdup", "error, failed to open \"%s\" for input", argv[optind]);
+        return 1;
+    }
+
+    strcat(wmode, "b"); // default if unknown suffix
+    sam_open_mode(wmode + strlen(wmode)-1, argv[optind + 1], NULL);
+    param.out = sam_open_format(argv[optind + 1], wmode, &ga.out);
+
+    if (!param.out) {
+        print_error_errno("markdup", "error, failed to open \"%s\" for output", argv[optind + 1]);
+        return 1;
+    }
+
+    if (ga.nthreads > 0)  {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            print_error("markdup", "error creating thread pool.\n");
+            return 1;
+        }
+
+        hts_set_opt(param.in,  HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(param.out, HTS_OPT_THREAD_POOL, &p);
+    }
+
+    // actual stuff happens here
+
+    // we need temp files so fix up the name here
+    if (tmpprefix.l == 0) {
+
+        if (strcmp(argv[optind + 1], "-") != 0)
+            ksprintf(&tmpprefix, "%s.", argv[optind + 1]);
+        else
+            kputc('.', &tmpprefix);
+    }
+
+    if (stat(tmpprefix.s, &st) == 0 && S_ISDIR(st.st_mode)) {
+        if (tmpprefix.s[tmpprefix.l-1] != '/') kputc('/', &tmpprefix);
+    }
+
+    t = ((unsigned) time(NULL)) ^ ((unsigned) clock());
+    ksprintf(&tmpprefix, "samtools.%d.%u.tmp", (int) getpid(), t % 10000);
+    param.prefix = tmpprefix.s;
+
+    param.arg_list = stringify_argv(argc + 1, argv - 1);
+    param.write_index = ga.write_index;
+    param.out_fn = argv[optind + 1];
+
+    ret = bam_mark_duplicates(&param);
+
+    sam_close(param.in);
+
+    if (sam_close(param.out) < 0) {
+        print_error("markdup", "error closing output file.\n");
+        ret = 1;
+    }
+
+    if (p.pool) hts_tpool_destroy(p.pool);
+
+    if (param.rgx) {
+        regfree(param.rgx);
+        free(param.rgx);
+    }
+
+    if (param.bc_rgx) {
+        regfree(param.bc_rgx);
+        free(param.bc_rgx);
+    }
+
+    free(param.arg_list);
+    free(tmpprefix.s);
+    sam_global_args_free(&ga);
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_mate.c

@@ -0,0 +1,728 @@
+/*  bam_mate.c -- fix mate pairing information and clean up flags.
+
+    Copyright (C) 2009, 2011-2017, 2019, 2022 Genome Research Ltd.
+    Portions copyright (C) 2011 Broad Institute.
+    Portions copyright (C) 2012 Peter Cock, The James Hutton Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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 notices 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.  */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include "htslib/kstring.h"
+#include "htslib/sam.h"
+#include "samtools.h"
+
+
+#define MD_MIN_QUALITY 15
+
+/*
+ * This function calculates ct tag for two bams, it assumes they are from the same template and
+ * writes the tag to the first read in position terms.
+ */
+static void bam_template_cigar(bam1_t *b1, bam1_t *b2, kstring_t *str)
+{
+    bam1_t *swap;
+    int i;
+    hts_pos_t end;
+    uint32_t *cigar;
+    str->l = 0;
+    if (b1->core.tid != b2->core.tid || b1->core.tid < 0 || b1->core.pos < 0 || b2->core.pos < 0 || b1->core.flag&BAM_FUNMAP || b2->core.flag&BAM_FUNMAP) return; // coordinateless or not on the same chr; skip
+    if (b1->core.pos > b2->core.pos) swap = b1, b1 = b2, b2 = swap; // make sure b1 has a smaller coordinate
+    kputc((b1->core.flag & BAM_FREAD1)? '1' : '2', str); // segment index
+    kputc((b1->core.flag & BAM_FREVERSE)? 'R' : 'F', str); // strand
+    for (i = 0, cigar = bam_get_cigar(b1); i < b1->core.n_cigar; ++i) {
+        kputw(bam_cigar_oplen(cigar[i]), str);
+        kputc(bam_cigar_opchr(cigar[i]), str);
+    }
+    end = bam_endpos(b1);
+    kputw(b2->core.pos - end, str);
+    kputc('T', str);
+    kputc((b2->core.flag & BAM_FREAD1)? '1' : '2', str); // segment index
+    kputc((b2->core.flag & BAM_FREVERSE)? 'R' : 'F', str); // strand
+    for (i = 0, cigar = bam_get_cigar(b2); i < b2->core.n_cigar; ++i) {
+        kputw(bam_cigar_oplen(cigar[i]), str);
+        kputc(bam_cigar_opchr(cigar[i]), str);
+    }
+
+    uint8_t* data;
+    if ((data = bam_aux_get(b1,"ct")) != NULL) bam_aux_del(b1, data);
+    if ((data = bam_aux_get(b2,"ct")) != NULL) bam_aux_del(b2, data);
+
+    bam_aux_append(b1, "ct", 'Z', str->l+1, (uint8_t*)str->s);
+}
+
+/*
+ * What This Program is Supposed To Do:
+ * Fill in mate coordinates, ISIZE and mate related flags from a name-sorted
+ * alignment.
+ *
+ * How We Handle Input
+ *
+ * Secondary and supplementary Reads:
+ * -write to output unchanged
+ * All Reads:
+ * -if pos == 0 (1 based), tid == -1 set UNMAPPED flag
+ * single Reads:
+ * -if pos == 0 (1 based), tid == -1, or UNMAPPED then set UNMAPPED, pos = 0,
+ *  tid = -1
+ * -clear bad flags (PAIRED, MREVERSE, PROPER_PAIR)
+ * -set mpos = 0 (1 based), mtid = -1 and isize = 0
+ * -write to output
+ * Paired Reads:
+ * -if read is unmapped and mate is not, set pos and tid to equal that of mate
+ * -sync mate flags (MREVERSE, MUNMAPPED), mpos, mtid
+ * -recalculate ISIZE if possible, otherwise set it to 0
+ * -optionally clear PROPER_PAIR flag from reads where mapping or orientation
+ *  indicate this is not possible (Illumina orientation only)
+ * -calculate ct and apply to lowest positioned read
+ * -write to output
+ * Limitations
+ * -Does not handle tandem reads
+ * -Should mark supplementary reads the same as primary.
+ * Notes
+ * -CT definition appears to be something else in spec, this was in here before
+ *  I started tampering with it, anyone know what is going on here? To work
+ *  around this I have demoted the CT this tool generates to ct.
+ */
+
+static void sync_unmapped_pos_inner(bam1_t* src, bam1_t* dest) {
+    if ((dest->core.flag & BAM_FUNMAP) && !(src->core.flag & BAM_FUNMAP)) {
+        // Set unmapped read's RNAME and POS to those of its mapped mate
+        // (recommended best practice, ensures if coord sort will be together)
+        dest->core.tid = src->core.tid;
+        dest->core.pos = src->core.pos;
+    }
+}
+
+static void sync_mate_inner(bam1_t* src, bam1_t* dest)
+{
+    // sync mate pos information
+    dest->core.mtid = src->core.tid; dest->core.mpos = src->core.pos;
+    // sync flag info
+    if (src->core.flag&BAM_FREVERSE)
+        dest->core.flag |= BAM_FMREVERSE;
+    else
+        dest->core.flag &= ~BAM_FMREVERSE;
+    if (src->core.flag & BAM_FUNMAP) {
+        dest->core.flag |= BAM_FMUNMAP;
+    }
+}
+
+// Is it plausible that these reads are properly paired?
+// Can't really give definitive answer without checking isize
+static bool plausibly_properly_paired(bam1_t* a, bam1_t* b)
+{
+    if ((a->core.flag & BAM_FUNMAP) || (b->core.flag & BAM_FUNMAP)) return false;
+    assert(a->core.tid >= 0); // This should never happen if FUNMAP is set correctly
+
+    if (a->core.tid != b->core.tid) return false;
+
+    bam1_t* first = a;
+    bam1_t* second = b;
+    hts_pos_t a_pos = a->core.flag&BAM_FREVERSE ? bam_endpos(a) : a->core.pos;
+    hts_pos_t  b_pos = b->core.flag&BAM_FREVERSE ? bam_endpos(b) : b->core.pos;
+    if (a_pos > b_pos) {
+        first = b;
+        second = a;
+    } else {
+        first = a;
+        second = b;
+    }
+
+    if (!(first->core.flag&BAM_FREVERSE) && (second->core.flag&BAM_FREVERSE))
+        return true;
+    else
+        return false;
+}
+
+// Returns 0 on success, -1 on failure.
+static int bam_format_cigar(const bam1_t* b, kstring_t* str)
+{
+    // An empty cigar is a special case return "*" rather than ""
+    if (b->core.n_cigar == 0) {
+        return (kputc('*', str) == EOF) ? -1 : 0;
+    }
+
+    const uint32_t *cigar = bam_get_cigar(b);
+    uint32_t i;
+
+    for (i = 0; i < b->core.n_cigar; ++i) {
+        if (kputw(bam_cigar_oplen(cigar[i]), str) == EOF) return -1;
+        if (kputc(bam_cigar_opchr(cigar[i]), str) == EOF) return -1;
+    }
+
+    return 0;
+}
+
+// Returns 0 on success, -1 on failure.
+static int sync_mq_mc(bam1_t* src, bam1_t* dest)
+{
+    if ( (src->core.flag & BAM_FUNMAP) == 0 ) { // If mapped
+        // Copy Mate Mapping Quality
+        uint32_t mq = src->core.qual;
+        uint8_t* data;
+        if ((data = bam_aux_get(dest,"MQ")) != NULL) {
+            bam_aux_del(dest, data);
+        }
+
+        bam_aux_append(dest, "MQ", 'i', sizeof(uint32_t), (uint8_t*)&mq);
+    }
+    // Copy mate cigar if either read is mapped
+    if ( (src->core.flag & BAM_FUNMAP) == 0 || (dest->core.flag & BAM_FUNMAP) == 0 ) {
+        uint8_t* data_mc;
+        if ((data_mc = bam_aux_get(dest,"MC")) != NULL) {
+            bam_aux_del(dest, data_mc);
+        }
+
+        // Convert cigar to string
+        kstring_t mc = { 0, 0, NULL };
+        if (bam_format_cigar(src, &mc) < 0) return -1;
+
+        bam_aux_append(dest, "MC", 'Z', ks_len(&mc)+1, (uint8_t*)ks_str(&mc));
+        free(mc.s);
+    }
+    return 0;
+}
+
+// Copy flags.
+// Returns 0 on success, -1 on failure.
+static int sync_mate(bam1_t* a, bam1_t* b)
+{
+    sync_unmapped_pos_inner(a,b);
+    sync_unmapped_pos_inner(b,a);
+    sync_mate_inner(a,b);
+    sync_mate_inner(b,a);
+    if (sync_mq_mc(a,b) < 0) return -1;
+    if (sync_mq_mc(b,a) < 0) return -1;
+    return 0;
+}
+
+
+static uint32_t calc_mate_score(bam1_t *b)
+{
+    uint32_t score = 0;
+    uint8_t  *qual = bam_get_qual(b);
+    int i;
+
+    for (i = 0; i < b->core.l_qseq; i++) {
+        if (qual[i] >= MD_MIN_QUALITY) score += qual[i];
+    }
+
+    return score;
+}
+
+
+static int add_mate_score(bam1_t *src, bam1_t *dest)
+{
+    uint8_t *data_ms;
+    uint32_t mate_score = calc_mate_score(src);
+
+    if ((data_ms = bam_aux_get(dest, "ms")) != NULL) {
+        bam_aux_del(dest, data_ms);
+    }
+
+    if (bam_aux_append(dest, "ms", 'i', sizeof(uint32_t), (uint8_t*)&mate_score) == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+
+// Completely delete the CIGAR field
+static void clear_cigar(bam1_t *b) {
+    memmove(bam_get_cigar(b), bam_get_seq(b),
+            b->data + b->l_data - bam_get_seq(b));
+    b->l_data -= 4*b->core.n_cigar;
+    b->core.n_cigar = 0;
+}
+
+// Trim a CIGAR field to end on reference position "end".  Remaining bases
+// are turned to soft clips.
+static int bam_trim(bam1_t *b, hts_pos_t end) {
+    hts_pos_t pos = b->core.pos;
+    int n_cigar = b->core.n_cigar, i;
+    uint32_t new_cigar_a[1024];
+    uint32_t *new_cigar = new_cigar_a;
+    uint32_t *cigar = bam_get_cigar(b);
+
+    // Find end of alignment or end of ref
+    int op = 0, oplen = 0;
+    for (i = 0; i < n_cigar; i++) {
+        op = bam_cigar_op(cigar[i]);
+        oplen = bam_cigar_oplen(cigar[i]);
+        if (!(bam_cigar_type(op) & 2))
+            continue;
+        pos += oplen;
+        if (pos > end)
+            break;
+    }
+
+    if (i == n_cigar)
+        // looks fine already
+        return 0;
+
+    int old_i = i, j = 0;
+    // At worst we grow by 1 element (eg 100M -> 70M30S)
+    if (n_cigar-i >= 1024-1) {
+        new_cigar = malloc(4*(n_cigar-i+1));
+        if (!new_cigar)
+            return -1;
+    }
+
+    // We fill out to new_cigar from here on.
+    if (pos-oplen < end) {
+        // Partial CIGAR op?  Split existing tag.
+        cigar[old_i++] = bam_cigar_gen(end - (pos-oplen), op);
+        new_cigar[j++] = bam_cigar_gen(pos-end, BAM_CSOFT_CLIP);
+    } else if (pos > end) {
+        // entirely off the chromosome; this will trigger CIGAR *, MQUAL 0
+        b->core.flag |= BAM_FUNMAP;
+        b->core.flag &= ~BAM_FPROPER_PAIR;
+    } else {
+        // CIGAR op started on the trim junction
+        new_cigar[j++] = bam_cigar_gen(oplen, BAM_CSOFT_CLIP);
+    }
+
+    // Replace trailing elements.
+    for (i++; i < n_cigar; i++) {
+        op = bam_cigar_op(cigar[i]);
+        oplen = bam_cigar_oplen(cigar[i]);
+        if (op == BAM_CHARD_CLIP) {
+            new_cigar[j++] = cigar[i];
+        } else {
+            new_cigar[j-1] =
+                bam_cigar_gen(bam_cigar_oplen(new_cigar[j-1]) + oplen,
+                              BAM_CSOFT_CLIP);
+        }
+    }
+
+    // We now have cigar[0..old_i-1] for existing CIGAR
+    // and new_cigar[0..j-1] for new CIGAR trailing component.
+
+    if (old_i+j == n_cigar) {
+        // Fits and no data move needed
+        memcpy(&cigar[old_i], new_cigar, j*4);
+    } else {
+        uint8_t *seq_old = bam_get_seq(b);
+        uint8_t *aux_end = b->data + b->l_data;
+        int nshift;
+        if (old_i+j < n_cigar) {
+            // Smaller, and can move data down
+            nshift = -4*(n_cigar - (old_i+j));
+        } else {
+            // Bigger, so grow BAM and move data up
+            nshift = 4*(old_i+j - n_cigar);
+            // FIXME: make htslib's sam_realloc_bam_data public
+            if (b->l_data + nshift > b->m_data) {
+                uint8_t *new_data = realloc(b->data, b->l_data + nshift);
+                if (!new_data) {
+                    if (new_cigar != new_cigar_a)
+                        free(new_cigar);
+                    return -1;
+                }
+                b->m_data = b->l_data + nshift;
+                if (b->data != new_data) {
+                    b->data = new_data;
+                    seq_old = bam_get_seq(b);
+                    aux_end = b->data + b->l_data;
+                    cigar = bam_get_cigar(b);
+                }
+            }
+        }
+        memmove(seq_old+nshift, seq_old, aux_end - seq_old);
+        b->l_data += nshift;
+        memcpy(&cigar[old_i], new_cigar, j*4);
+        b->core.n_cigar = old_i+j;
+    }
+
+    if (new_cigar != new_cigar_a)
+        free(new_cigar);
+
+    return 0;
+}
+
+// Parses a comma-separated list of "pos", "mqual", "unmap", "cigar", and "aux"
+// keywords for the bam sanitizer.
+int bam_sanitize_options(const char *str) {
+    int opt = 0;
+
+    while (str && *str) {
+        const char *str_start;
+        while(*str && *str == ',')
+            str++;
+
+        for (str_start = str; *str && *str != ','; str++);
+        int len = str - str_start;
+        if (strncmp(str_start, "all", 3) == 0 || *str_start == '*')
+            opt = FIX_ALL;
+        else if (strncmp(str_start, "none", 4) == 0 ||
+                 strncmp(str_start, "off", 3) == 0)
+            opt = 0;
+        else if (strncmp(str_start, "on", 2) == 0)
+            // default for position sorted data
+            opt = FIX_MQUAL | FIX_UNMAP | FIX_CIGAR | FIX_AUX;
+        else if (strncmp(str_start, "pos", 3) == 0)
+            opt |= FIX_POS;
+        else if (strncmp(str_start, "mqual", 5) == 0)
+            opt |= FIX_MQUAL;
+        else if (strncmp(str_start, "unmap", 5) == 0)
+            opt |= FIX_UNMAP;
+        else if (strncmp(str_start, "cigar", 5) == 0)
+            opt |= FIX_CIGAR;
+        else if (strncmp(str_start, "aux", 3) == 0)
+            opt |= FIX_AUX;
+        else {
+            print_error("sanitize", "Unrecognised keyword %.*s\n",
+                        len, str_start);
+            return -1;
+        }
+    }
+
+    return opt;
+}
+
+int bam_sanitize(sam_hdr_t *h, bam1_t *b, int flags) {
+    if ((flags & FIX_POS) && b->core.tid < 0) {
+        // RNAME * => pos 0. NB can break alignment chr/pos sort order
+        b->core.pos = -1;
+        if (flags & FIX_UNMAP)
+            b->core.flag |= BAM_FUNMAP;
+    }
+
+    if ((flags & FIX_CIGAR) && !(b->core.flag & BAM_FUNMAP)) {
+        // Mapped => unmapped correction
+        if (b->core.pos < 0 && (flags & FIX_UNMAP)) {
+            b->core.flag |= BAM_FUNMAP;
+        } else {
+            hts_pos_t cur_end, rlen = sam_hdr_tid2len(h, b->core.tid);
+            if (b->core.pos >= rlen && (flags & FIX_UNMAP)) {
+                b->core.flag |= BAM_FUNMAP;
+                if (flags & FIX_POS)
+                    b->core.tid = b->core.pos = -1;
+            } else if ((cur_end = bam_endpos(b)) > rlen) {
+                if (bam_trim(b, rlen) < 0)
+                    return -1;
+            }
+        }
+    }
+
+    if (b->core.flag & BAM_FUNMAP) {
+        // Unmapped -> cigar/qual correctoins
+        if ((flags & FIX_CIGAR) && b->core.n_cigar > 0)
+            clear_cigar(b);
+
+        if (flags & FIX_MQUAL)
+            b->core.qual = 0;
+
+        // Remove NM, MD, CG, SM tags.
+        if (flags & FIX_AUX) {
+            uint8_t *from = bam_aux_first(b);
+            uint8_t *end = b->data + b->l_data;
+            uint8_t *to = from ? from-2 : end;
+
+#define XTAG(a) (((a)[0]<<8) + (a)[1])
+            while (from) {
+                uint8_t *next = bam_aux_next(b, from);
+                if (!next && errno != ENOENT)
+                    return -1;
+
+                // Keep tag unless one of a specific set.
+                // NB "to" always points to an aux tag start, while
+                // "from" is after key.
+                from -= 2;
+                int key = (int)from[0]<<8 | from[1];
+                if (key != XTAG("NM") && key != XTAG("MD") &&
+                    key != XTAG("CG") && key != XTAG("SM")) {
+                    ptrdiff_t len = (next ? next-2 : end) - from;
+                    if (from != to)
+                        memmove(to, from, len);
+                    to += len;
+                }
+                from = next;
+            }
+            b->l_data = to - b->data;
+        }
+    }
+
+    return 0;
+}
+
+// currently, this function ONLY works if each read has one hit
+static int bam_mating_core(samFile *in, samFile *out, int remove_reads,
+                           int proper_pair_check, int add_ct,
+                           int do_mate_scoring, char *arg_list, int no_pg,
+                           int sanitize_flags)
+{
+    sam_hdr_t *header;
+    bam1_t *b[2] = { NULL, NULL };
+    int curr, has_prev, result;
+    hts_pos_t pre_end = 0, cur_end = 0;
+    kstring_t str = KS_INITIALIZE;
+
+    header = sam_hdr_read(in);
+    if (header == NULL) {
+        fprintf(stderr, "[bam_mating_core] ERROR: Couldn't read header\n");
+        return 1;
+    }
+
+    // Accept unknown, unsorted, or queryname sort order, but error on coordinate sorted.
+    if (!sam_hdr_find_tag_hd(header, "SO", &str) && str.s && !strcmp(str.s, "coordinate")) {
+        fprintf(stderr, "[bam_mating_core] ERROR: Coordinate sorted, require grouped/sorted by queryname.\n");
+        goto fail;
+    }
+    ks_free(&str);
+
+    if (!no_pg && sam_hdr_add_pg(header, "samtools",
+                                 "VN", samtools_version(),
+                                 arg_list ? "CL": NULL,
+                                 arg_list ? arg_list : NULL,
+                                 NULL))
+        goto fail;
+
+    if (sam_hdr_write(out, header) < 0) goto write_fail;
+
+    b[0] = bam_init1();
+    b[1] = bam_init1();
+    curr = 0; has_prev = 0;
+    while ((result = sam_read1(in, header, b[curr])) >= 0) {
+        bam1_t *cur = b[curr], *pre = b[1-curr];
+        if (bam_sanitize(header, cur, sanitize_flags) < 0)
+            goto fail;
+        if (cur->core.flag & BAM_FSECONDARY)
+        {
+            if ( !remove_reads ) {
+                if (sam_write1(out, header, cur) < 0) goto write_fail;
+            }
+            continue; // skip secondary alignments
+        }
+        if (cur->core.flag & BAM_FSUPPLEMENTARY)
+        {
+            if (sam_write1(out, header, cur) < 0) goto write_fail;
+            continue; // pass supplementary alignments through unchanged (TODO:make them match read they came from)
+        }
+        if ((cur->core.flag&BAM_FUNMAP) == 0) // If mapped calculate end
+        {
+            cur_end = bam_endpos(cur);
+        }
+
+        if (has_prev) { // do we have a pair of reads to examine?
+            if (strcmp(bam_get_qname(cur), bam_get_qname(pre)) == 0) { // identical pair name
+                pre->core.flag |= BAM_FPAIRED;
+                cur->core.flag |= BAM_FPAIRED;
+                if (sync_mate(pre, cur)) goto fail;
+
+                if (pre->core.tid == cur->core.tid && !(cur->core.flag&(BAM_FUNMAP|BAM_FMUNMAP))
+                    && !(pre->core.flag&(BAM_FUNMAP|BAM_FMUNMAP))) // if safe set TLEN/ISIZE
+                {
+                    hts_pos_t cur5, pre5;
+                    cur5 = (cur->core.flag&BAM_FREVERSE)? cur_end : cur->core.pos;
+                    pre5 = (pre->core.flag&BAM_FREVERSE)? pre_end : pre->core.pos;
+                    cur->core.isize = pre5 - cur5; pre->core.isize = cur5 - pre5;
+                } else cur->core.isize = pre->core.isize = 0;
+                if (add_ct) bam_template_cigar(pre, cur, &str);
+                // TODO: Add code to properly check if read is in a proper pair based on ISIZE distribution
+                if (proper_pair_check && !plausibly_properly_paired(pre,cur)) {
+                    pre->core.flag &= ~BAM_FPROPER_PAIR;
+                    cur->core.flag &= ~BAM_FPROPER_PAIR;
+                }
+
+                if (do_mate_scoring) {
+                    if ((add_mate_score(pre, cur) == -1) || (add_mate_score(cur, pre) == -1)) {
+                        fprintf(stderr, "[bam_mating_core] ERROR: unable to add mate score.\n");
+                        goto fail;
+                    }
+                }
+
+                // Write out result
+                if ( !remove_reads ) {
+                    if (sam_write1(out, header, pre) < 0) goto write_fail;
+                    if (sam_write1(out, header, cur) < 0) goto write_fail;
+                } else {
+                    // If we have to remove reads make sure we do it in a way that doesn't create orphans with bad flags
+                    if(pre->core.flag&BAM_FUNMAP) cur->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                    if(cur->core.flag&BAM_FUNMAP) pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                    if(!(pre->core.flag&BAM_FUNMAP)) {
+                        if (sam_write1(out, header, pre) < 0) goto write_fail;
+                    }
+                    if(!(cur->core.flag&BAM_FUNMAP)) {
+                        if (sam_write1(out, header, cur) < 0) goto write_fail;
+                    }
+                }
+                has_prev = 0;
+            } else { // unpaired?  clear bad info and write it out
+                pre->core.mtid = -1; pre->core.mpos = -1; pre->core.isize = 0;
+                pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                if ( !remove_reads || !(pre->core.flag&BAM_FUNMAP) ) {
+                    if (sam_write1(out, header, pre) < 0) goto write_fail;
+                }
+            }
+        } else has_prev = 1;
+        curr = 1 - curr;
+        pre_end = cur_end;
+    }
+    if (result < -1) goto read_fail;
+    if (has_prev && !remove_reads) { // If we still have a BAM in the buffer it must be unpaired
+        bam1_t *pre = b[1-curr];
+        if (pre->core.tid < 0 || pre->core.pos < 0 || pre->core.flag&BAM_FUNMAP) { // If unmapped
+            pre->core.flag |= BAM_FUNMAP;
+            pre->core.tid = -1;
+            pre->core.pos = -1;
+        }
+        pre->core.mtid = -1; pre->core.mpos = -1; pre->core.isize = 0;
+        pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+
+        if (sam_write1(out, header, pre) < 0) goto write_fail;
+    }
+    sam_hdr_destroy(header);
+    bam_destroy1(b[0]);
+    bam_destroy1(b[1]);
+    ks_free(&str);
+    return 0;
+
+ read_fail:
+    print_error("fixmate", "Couldn't read from input file");
+    goto fail;
+
+ write_fail:
+    print_error_errno("fixmate", "Couldn't write to output file");
+ fail:
+    sam_hdr_destroy(header);
+    bam_destroy1(b[0]);
+    bam_destroy1(b[1]);
+    ks_free(&str);
+    return 1;
+}
+
+void usage(FILE* where)
+{
+    fprintf(where,
+"Usage: samtools fixmate <in.nameSrt.bam> <out.nameSrt.bam>\n"
+"Options:\n"
+"  -r           Remove unmapped reads and secondary alignments\n"
+"  -p           Disable FR proper pair check\n"
+"  -c           Add template cigar ct tag\n"
+"  -m           Add mate score tag\n"
+"  -u           Uncompressed output\n"
+"  -z, --sanitize FLAG[,FLAG]\n"
+"               Sanitize alignment fields [defaults to all types]\n"
+"  --no-PG      do not add a PG line\n");
+
+    sam_global_opt_help(where, "-.O..@-.");
+
+    fprintf(where,
+"\n"
+"As elsewhere in samtools, use '-' as the filename for stdin/stdout. The input\n"
+"file must be grouped by read name (e.g. sorted by name). Coordinated sorted\n"
+"input is not accepted.\n");
+}
+
+int bam_mating(int argc, char *argv[])
+{
+    htsThreadPool p = {NULL, 0};
+    samFile *in = NULL, *out = NULL;
+    int c, remove_reads = 0, proper_pair_check = 1, add_ct = 0, res = 1,
+        mate_score = 0, no_pg = 0, sanitize_flags = FIX_ALL;
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    char wmode[4] = {'w', 'b', 0, 0};
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+    char *arg_list = NULL;
+
+    // parse args
+    if (argc == 1) { usage(stdout); return 0; }
+    while ((c = getopt_long(argc, argv, "rpcmO:@:uz:", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'r': remove_reads = 1; break;
+        case 'p': proper_pair_check = 0; break;
+        case 'c': add_ct = 1; break;
+        case 'm': mate_score = 1; break;
+        case 'u': wmode[2] = '0'; break;
+        case 1: no_pg = 1; break;
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?': usage(stderr); goto fail;
+        case 'z':
+            if ((sanitize_flags = bam_sanitize_options(optarg)) < 0)
+                exit(1);
+            break;
+        }
+    }
+    if (optind+1 >= argc) { usage(stderr); goto fail; }
+
+    if (!no_pg && !(arg_list =  stringify_argv(argc+1, argv-1)))
+        goto fail;
+
+    // init
+    if ((in = sam_open_format(argv[optind], "rb", &ga.in)) == NULL) {
+        print_error_errno("fixmate", "cannot open input file");
+        goto fail;
+    }
+    sam_open_mode(wmode+1, argv[optind+1], NULL);
+    if ((out = sam_open_format(argv[optind+1], wmode, &ga.out)) == NULL) {
+        print_error_errno("fixmate", "cannot open output file");
+        goto fail;
+    }
+
+    if (ga.nthreads > 0) {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            fprintf(stderr, "Error creating thread pool\n");
+            goto fail;
+        }
+        hts_set_opt(in,  HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(out, HTS_OPT_THREAD_POOL, &p);
+    }
+
+    // run
+    res = bam_mating_core(in, out, remove_reads, proper_pair_check, add_ct,
+                          mate_score, arg_list, no_pg, sanitize_flags);
+
+    // cleanup
+    sam_close(in);
+    if (sam_close(out) < 0) {
+        fprintf(stderr, "[bam_mating] error while closing output file\n");
+        res = 1;
+    }
+
+    if (p.pool) hts_tpool_destroy(p.pool);
+    free(arg_list);
+    sam_global_args_free(&ga);
+    return res;
+
+ fail:
+    if (in) sam_close(in);
+    if (out) sam_close(out);
+    if (p.pool) hts_tpool_destroy(p.pool);
+    free(arg_list);
+    sam_global_args_free(&ga);
+    return 1;
+}
+
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_mate.c.pysam.c

@@ -0,0 +1,730 @@
+#include "samtools.pysam.h"
+
+/*  bam_mate.c -- fix mate pairing information and clean up flags.
+
+    Copyright (C) 2009, 2011-2017, 2019, 2022 Genome Research Ltd.
+    Portions copyright (C) 2011 Broad Institute.
+    Portions copyright (C) 2012 Peter Cock, The James Hutton Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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 notices 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.  */
+
+#include <config.h>
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include "htslib/kstring.h"
+#include "htslib/sam.h"
+#include "samtools.h"
+
+
+#define MD_MIN_QUALITY 15
+
+/*
+ * This function calculates ct tag for two bams, it assumes they are from the same template and
+ * writes the tag to the first read in position terms.
+ */
+static void bam_template_cigar(bam1_t *b1, bam1_t *b2, kstring_t *str)
+{
+    bam1_t *swap;
+    int i;
+    hts_pos_t end;
+    uint32_t *cigar;
+    str->l = 0;
+    if (b1->core.tid != b2->core.tid || b1->core.tid < 0 || b1->core.pos < 0 || b2->core.pos < 0 || b1->core.flag&BAM_FUNMAP || b2->core.flag&BAM_FUNMAP) return; // coordinateless or not on the same chr; skip
+    if (b1->core.pos > b2->core.pos) swap = b1, b1 = b2, b2 = swap; // make sure b1 has a smaller coordinate
+    kputc((b1->core.flag & BAM_FREAD1)? '1' : '2', str); // segment index
+    kputc((b1->core.flag & BAM_FREVERSE)? 'R' : 'F', str); // strand
+    for (i = 0, cigar = bam_get_cigar(b1); i < b1->core.n_cigar; ++i) {
+        kputw(bam_cigar_oplen(cigar[i]), str);
+        kputc(bam_cigar_opchr(cigar[i]), str);
+    }
+    end = bam_endpos(b1);
+    kputw(b2->core.pos - end, str);
+    kputc('T', str);
+    kputc((b2->core.flag & BAM_FREAD1)? '1' : '2', str); // segment index
+    kputc((b2->core.flag & BAM_FREVERSE)? 'R' : 'F', str); // strand
+    for (i = 0, cigar = bam_get_cigar(b2); i < b2->core.n_cigar; ++i) {
+        kputw(bam_cigar_oplen(cigar[i]), str);
+        kputc(bam_cigar_opchr(cigar[i]), str);
+    }
+
+    uint8_t* data;
+    if ((data = bam_aux_get(b1,"ct")) != NULL) bam_aux_del(b1, data);
+    if ((data = bam_aux_get(b2,"ct")) != NULL) bam_aux_del(b2, data);
+
+    bam_aux_append(b1, "ct", 'Z', str->l+1, (uint8_t*)str->s);
+}
+
+/*
+ * What This Program is Supposed To Do:
+ * Fill in mate coordinates, ISIZE and mate related flags from a name-sorted
+ * alignment.
+ *
+ * How We Handle Input
+ *
+ * Secondary and supplementary Reads:
+ * -write to output unchanged
+ * All Reads:
+ * -if pos == 0 (1 based), tid == -1 set UNMAPPED flag
+ * single Reads:
+ * -if pos == 0 (1 based), tid == -1, or UNMAPPED then set UNMAPPED, pos = 0,
+ *  tid = -1
+ * -clear bad flags (PAIRED, MREVERSE, PROPER_PAIR)
+ * -set mpos = 0 (1 based), mtid = -1 and isize = 0
+ * -write to output
+ * Paired Reads:
+ * -if read is unmapped and mate is not, set pos and tid to equal that of mate
+ * -sync mate flags (MREVERSE, MUNMAPPED), mpos, mtid
+ * -recalculate ISIZE if possible, otherwise set it to 0
+ * -optionally clear PROPER_PAIR flag from reads where mapping or orientation
+ *  indicate this is not possible (Illumina orientation only)
+ * -calculate ct and apply to lowest positioned read
+ * -write to output
+ * Limitations
+ * -Does not handle tandem reads
+ * -Should mark supplementary reads the same as primary.
+ * Notes
+ * -CT definition appears to be something else in spec, this was in here before
+ *  I started tampering with it, anyone know what is going on here? To work
+ *  around this I have demoted the CT this tool generates to ct.
+ */
+
+static void sync_unmapped_pos_inner(bam1_t* src, bam1_t* dest) {
+    if ((dest->core.flag & BAM_FUNMAP) && !(src->core.flag & BAM_FUNMAP)) {
+        // Set unmapped read's RNAME and POS to those of its mapped mate
+        // (recommended best practice, ensures if coord sort will be together)
+        dest->core.tid = src->core.tid;
+        dest->core.pos = src->core.pos;
+    }
+}
+
+static void sync_mate_inner(bam1_t* src, bam1_t* dest)
+{
+    // sync mate pos information
+    dest->core.mtid = src->core.tid; dest->core.mpos = src->core.pos;
+    // sync flag info
+    if (src->core.flag&BAM_FREVERSE)
+        dest->core.flag |= BAM_FMREVERSE;
+    else
+        dest->core.flag &= ~BAM_FMREVERSE;
+    if (src->core.flag & BAM_FUNMAP) {
+        dest->core.flag |= BAM_FMUNMAP;
+    }
+}
+
+// Is it plausible that these reads are properly paired?
+// Can't really give definitive answer without checking isize
+static bool plausibly_properly_paired(bam1_t* a, bam1_t* b)
+{
+    if ((a->core.flag & BAM_FUNMAP) || (b->core.flag & BAM_FUNMAP)) return false;
+    assert(a->core.tid >= 0); // This should never happen if FUNMAP is set correctly
+
+    if (a->core.tid != b->core.tid) return false;
+
+    bam1_t* first = a;
+    bam1_t* second = b;
+    hts_pos_t a_pos = a->core.flag&BAM_FREVERSE ? bam_endpos(a) : a->core.pos;
+    hts_pos_t  b_pos = b->core.flag&BAM_FREVERSE ? bam_endpos(b) : b->core.pos;
+    if (a_pos > b_pos) {
+        first = b;
+        second = a;
+    } else {
+        first = a;
+        second = b;
+    }
+
+    if (!(first->core.flag&BAM_FREVERSE) && (second->core.flag&BAM_FREVERSE))
+        return true;
+    else
+        return false;
+}
+
+// Returns 0 on success, -1 on failure.
+static int bam_format_cigar(const bam1_t* b, kstring_t* str)
+{
+    // An empty cigar is a special case return "*" rather than ""
+    if (b->core.n_cigar == 0) {
+        return (kputc('*', str) == EOF) ? -1 : 0;
+    }
+
+    const uint32_t *cigar = bam_get_cigar(b);
+    uint32_t i;
+
+    for (i = 0; i < b->core.n_cigar; ++i) {
+        if (kputw(bam_cigar_oplen(cigar[i]), str) == EOF) return -1;
+        if (kputc(bam_cigar_opchr(cigar[i]), str) == EOF) return -1;
+    }
+
+    return 0;
+}
+
+// Returns 0 on success, -1 on failure.
+static int sync_mq_mc(bam1_t* src, bam1_t* dest)
+{
+    if ( (src->core.flag & BAM_FUNMAP) == 0 ) { // If mapped
+        // Copy Mate Mapping Quality
+        uint32_t mq = src->core.qual;
+        uint8_t* data;
+        if ((data = bam_aux_get(dest,"MQ")) != NULL) {
+            bam_aux_del(dest, data);
+        }
+
+        bam_aux_append(dest, "MQ", 'i', sizeof(uint32_t), (uint8_t*)&mq);
+    }
+    // Copy mate cigar if either read is mapped
+    if ( (src->core.flag & BAM_FUNMAP) == 0 || (dest->core.flag & BAM_FUNMAP) == 0 ) {
+        uint8_t* data_mc;
+        if ((data_mc = bam_aux_get(dest,"MC")) != NULL) {
+            bam_aux_del(dest, data_mc);
+        }
+
+        // Convert cigar to string
+        kstring_t mc = { 0, 0, NULL };
+        if (bam_format_cigar(src, &mc) < 0) return -1;
+
+        bam_aux_append(dest, "MC", 'Z', ks_len(&mc)+1, (uint8_t*)ks_str(&mc));
+        free(mc.s);
+    }
+    return 0;
+}
+
+// Copy flags.
+// Returns 0 on success, -1 on failure.
+static int sync_mate(bam1_t* a, bam1_t* b)
+{
+    sync_unmapped_pos_inner(a,b);
+    sync_unmapped_pos_inner(b,a);
+    sync_mate_inner(a,b);
+    sync_mate_inner(b,a);
+    if (sync_mq_mc(a,b) < 0) return -1;
+    if (sync_mq_mc(b,a) < 0) return -1;
+    return 0;
+}
+
+
+static uint32_t calc_mate_score(bam1_t *b)
+{
+    uint32_t score = 0;
+    uint8_t  *qual = bam_get_qual(b);
+    int i;
+
+    for (i = 0; i < b->core.l_qseq; i++) {
+        if (qual[i] >= MD_MIN_QUALITY) score += qual[i];
+    }
+
+    return score;
+}
+
+
+static int add_mate_score(bam1_t *src, bam1_t *dest)
+{
+    uint8_t *data_ms;
+    uint32_t mate_score = calc_mate_score(src);
+
+    if ((data_ms = bam_aux_get(dest, "ms")) != NULL) {
+        bam_aux_del(dest, data_ms);
+    }
+
+    if (bam_aux_append(dest, "ms", 'i', sizeof(uint32_t), (uint8_t*)&mate_score) == -1) {
+        return -1;
+    }
+
+    return 0;
+}
+
+// Completely delete the CIGAR field
+static void clear_cigar(bam1_t *b) {
+    memmove(bam_get_cigar(b), bam_get_seq(b),
+            b->data + b->l_data - bam_get_seq(b));
+    b->l_data -= 4*b->core.n_cigar;
+    b->core.n_cigar = 0;
+}
+
+// Trim a CIGAR field to end on reference position "end".  Remaining bases
+// are turned to soft clips.
+static int bam_trim(bam1_t *b, hts_pos_t end) {
+    hts_pos_t pos = b->core.pos;
+    int n_cigar = b->core.n_cigar, i;
+    uint32_t new_cigar_a[1024];
+    uint32_t *new_cigar = new_cigar_a;
+    uint32_t *cigar = bam_get_cigar(b);
+
+    // Find end of alignment or end of ref
+    int op = 0, oplen = 0;
+    for (i = 0; i < n_cigar; i++) {
+        op = bam_cigar_op(cigar[i]);
+        oplen = bam_cigar_oplen(cigar[i]);
+        if (!(bam_cigar_type(op) & 2))
+            continue;
+        pos += oplen;
+        if (pos > end)
+            break;
+    }
+
+    if (i == n_cigar)
+        // looks fine already
+        return 0;
+
+    int old_i = i, j = 0;
+    // At worst we grow by 1 element (eg 100M -> 70M30S)
+    if (n_cigar-i >= 1024-1) {
+        new_cigar = malloc(4*(n_cigar-i+1));
+        if (!new_cigar)
+            return -1;
+    }
+
+    // We fill out to new_cigar from here on.
+    if (pos-oplen < end) {
+        // Partial CIGAR op?  Split existing tag.
+        cigar[old_i++] = bam_cigar_gen(end - (pos-oplen), op);
+        new_cigar[j++] = bam_cigar_gen(pos-end, BAM_CSOFT_CLIP);
+    } else if (pos > end) {
+        // entirely off the chromosome; this will trigger CIGAR *, MQUAL 0
+        b->core.flag |= BAM_FUNMAP;
+        b->core.flag &= ~BAM_FPROPER_PAIR;
+    } else {
+        // CIGAR op started on the trim junction
+        new_cigar[j++] = bam_cigar_gen(oplen, BAM_CSOFT_CLIP);
+    }
+
+    // Replace trailing elements.
+    for (i++; i < n_cigar; i++) {
+        op = bam_cigar_op(cigar[i]);
+        oplen = bam_cigar_oplen(cigar[i]);
+        if (op == BAM_CHARD_CLIP) {
+            new_cigar[j++] = cigar[i];
+        } else {
+            new_cigar[j-1] =
+                bam_cigar_gen(bam_cigar_oplen(new_cigar[j-1]) + oplen,
+                              BAM_CSOFT_CLIP);
+        }
+    }
+
+    // We now have cigar[0..old_i-1] for existing CIGAR
+    // and new_cigar[0..j-1] for new CIGAR trailing component.
+
+    if (old_i+j == n_cigar) {
+        // Fits and no data move needed
+        memcpy(&cigar[old_i], new_cigar, j*4);
+    } else {
+        uint8_t *seq_old = bam_get_seq(b);
+        uint8_t *aux_end = b->data + b->l_data;
+        int nshift;
+        if (old_i+j < n_cigar) {
+            // Smaller, and can move data down
+            nshift = -4*(n_cigar - (old_i+j));
+        } else {
+            // Bigger, so grow BAM and move data up
+            nshift = 4*(old_i+j - n_cigar);
+            // FIXME: make htslib's sam_realloc_bam_data public
+            if (b->l_data + nshift > b->m_data) {
+                uint8_t *new_data = realloc(b->data, b->l_data + nshift);
+                if (!new_data) {
+                    if (new_cigar != new_cigar_a)
+                        free(new_cigar);
+                    return -1;
+                }
+                b->m_data = b->l_data + nshift;
+                if (b->data != new_data) {
+                    b->data = new_data;
+                    seq_old = bam_get_seq(b);
+                    aux_end = b->data + b->l_data;
+                    cigar = bam_get_cigar(b);
+                }
+            }
+        }
+        memmove(seq_old+nshift, seq_old, aux_end - seq_old);
+        b->l_data += nshift;
+        memcpy(&cigar[old_i], new_cigar, j*4);
+        b->core.n_cigar = old_i+j;
+    }
+
+    if (new_cigar != new_cigar_a)
+        free(new_cigar);
+
+    return 0;
+}
+
+// Parses a comma-separated list of "pos", "mqual", "unmap", "cigar", and "aux"
+// keywords for the bam sanitizer.
+int bam_sanitize_options(const char *str) {
+    int opt = 0;
+
+    while (str && *str) {
+        const char *str_start;
+        while(*str && *str == ',')
+            str++;
+
+        for (str_start = str; *str && *str != ','; str++);
+        int len = str - str_start;
+        if (strncmp(str_start, "all", 3) == 0 || *str_start == '*')
+            opt = FIX_ALL;
+        else if (strncmp(str_start, "none", 4) == 0 ||
+                 strncmp(str_start, "off", 3) == 0)
+            opt = 0;
+        else if (strncmp(str_start, "on", 2) == 0)
+            // default for position sorted data
+            opt = FIX_MQUAL | FIX_UNMAP | FIX_CIGAR | FIX_AUX;
+        else if (strncmp(str_start, "pos", 3) == 0)
+            opt |= FIX_POS;
+        else if (strncmp(str_start, "mqual", 5) == 0)
+            opt |= FIX_MQUAL;
+        else if (strncmp(str_start, "unmap", 5) == 0)
+            opt |= FIX_UNMAP;
+        else if (strncmp(str_start, "cigar", 5) == 0)
+            opt |= FIX_CIGAR;
+        else if (strncmp(str_start, "aux", 3) == 0)
+            opt |= FIX_AUX;
+        else {
+            print_error("sanitize", "Unrecognised keyword %.*s\n",
+                        len, str_start);
+            return -1;
+        }
+    }
+
+    return opt;
+}
+
+int bam_sanitize(sam_hdr_t *h, bam1_t *b, int flags) {
+    if ((flags & FIX_POS) && b->core.tid < 0) {
+        // RNAME * => pos 0. NB can break alignment chr/pos sort order
+        b->core.pos = -1;
+        if (flags & FIX_UNMAP)
+            b->core.flag |= BAM_FUNMAP;
+    }
+
+    if ((flags & FIX_CIGAR) && !(b->core.flag & BAM_FUNMAP)) {
+        // Mapped => unmapped correction
+        if (b->core.pos < 0 && (flags & FIX_UNMAP)) {
+            b->core.flag |= BAM_FUNMAP;
+        } else {
+            hts_pos_t cur_end, rlen = sam_hdr_tid2len(h, b->core.tid);
+            if (b->core.pos >= rlen && (flags & FIX_UNMAP)) {
+                b->core.flag |= BAM_FUNMAP;
+                if (flags & FIX_POS)
+                    b->core.tid = b->core.pos = -1;
+            } else if ((cur_end = bam_endpos(b)) > rlen) {
+                if (bam_trim(b, rlen) < 0)
+                    return -1;
+            }
+        }
+    }
+
+    if (b->core.flag & BAM_FUNMAP) {
+        // Unmapped -> cigar/qual correctoins
+        if ((flags & FIX_CIGAR) && b->core.n_cigar > 0)
+            clear_cigar(b);
+
+        if (flags & FIX_MQUAL)
+            b->core.qual = 0;
+
+        // Remove NM, MD, CG, SM tags.
+        if (flags & FIX_AUX) {
+            uint8_t *from = bam_aux_first(b);
+            uint8_t *end = b->data + b->l_data;
+            uint8_t *to = from ? from-2 : end;
+
+#define XTAG(a) (((a)[0]<<8) + (a)[1])
+            while (from) {
+                uint8_t *next = bam_aux_next(b, from);
+                if (!next && errno != ENOENT)
+                    return -1;
+
+                // Keep tag unless one of a specific set.
+                // NB "to" always points to an aux tag start, while
+                // "from" is after key.
+                from -= 2;
+                int key = (int)from[0]<<8 | from[1];
+                if (key != XTAG("NM") && key != XTAG("MD") &&
+                    key != XTAG("CG") && key != XTAG("SM")) {
+                    ptrdiff_t len = (next ? next-2 : end) - from;
+                    if (from != to)
+                        memmove(to, from, len);
+                    to += len;
+                }
+                from = next;
+            }
+            b->l_data = to - b->data;
+        }
+    }
+
+    return 0;
+}
+
+// currently, this function ONLY works if each read has one hit
+static int bam_mating_core(samFile *in, samFile *out, int remove_reads,
+                           int proper_pair_check, int add_ct,
+                           int do_mate_scoring, char *arg_list, int no_pg,
+                           int sanitize_flags)
+{
+    sam_hdr_t *header;
+    bam1_t *b[2] = { NULL, NULL };
+    int curr, has_prev, result;
+    hts_pos_t pre_end = 0, cur_end = 0;
+    kstring_t str = KS_INITIALIZE;
+
+    header = sam_hdr_read(in);
+    if (header == NULL) {
+        fprintf(samtools_stderr, "[bam_mating_core] ERROR: Couldn't read header\n");
+        return 1;
+    }
+
+    // Accept unknown, unsorted, or queryname sort order, but error on coordinate sorted.
+    if (!sam_hdr_find_tag_hd(header, "SO", &str) && str.s && !strcmp(str.s, "coordinate")) {
+        fprintf(samtools_stderr, "[bam_mating_core] ERROR: Coordinate sorted, require grouped/sorted by queryname.\n");
+        goto fail;
+    }
+    ks_free(&str);
+
+    if (!no_pg && sam_hdr_add_pg(header, "samtools",
+                                 "VN", samtools_version(),
+                                 arg_list ? "CL": NULL,
+                                 arg_list ? arg_list : NULL,
+                                 NULL))
+        goto fail;
+
+    if (sam_hdr_write(out, header) < 0) goto write_fail;
+
+    b[0] = bam_init1();
+    b[1] = bam_init1();
+    curr = 0; has_prev = 0;
+    while ((result = sam_read1(in, header, b[curr])) >= 0) {
+        bam1_t *cur = b[curr], *pre = b[1-curr];
+        if (bam_sanitize(header, cur, sanitize_flags) < 0)
+            goto fail;
+        if (cur->core.flag & BAM_FSECONDARY)
+        {
+            if ( !remove_reads ) {
+                if (sam_write1(out, header, cur) < 0) goto write_fail;
+            }
+            continue; // skip secondary alignments
+        }
+        if (cur->core.flag & BAM_FSUPPLEMENTARY)
+        {
+            if (sam_write1(out, header, cur) < 0) goto write_fail;
+            continue; // pass supplementary alignments through unchanged (TODO:make them match read they came from)
+        }
+        if ((cur->core.flag&BAM_FUNMAP) == 0) // If mapped calculate end
+        {
+            cur_end = bam_endpos(cur);
+        }
+
+        if (has_prev) { // do we have a pair of reads to examine?
+            if (strcmp(bam_get_qname(cur), bam_get_qname(pre)) == 0) { // identical pair name
+                pre->core.flag |= BAM_FPAIRED;
+                cur->core.flag |= BAM_FPAIRED;
+                if (sync_mate(pre, cur)) goto fail;
+
+                if (pre->core.tid == cur->core.tid && !(cur->core.flag&(BAM_FUNMAP|BAM_FMUNMAP))
+                    && !(pre->core.flag&(BAM_FUNMAP|BAM_FMUNMAP))) // if safe set TLEN/ISIZE
+                {
+                    hts_pos_t cur5, pre5;
+                    cur5 = (cur->core.flag&BAM_FREVERSE)? cur_end : cur->core.pos;
+                    pre5 = (pre->core.flag&BAM_FREVERSE)? pre_end : pre->core.pos;
+                    cur->core.isize = pre5 - cur5; pre->core.isize = cur5 - pre5;
+                } else cur->core.isize = pre->core.isize = 0;
+                if (add_ct) bam_template_cigar(pre, cur, &str);
+                // TODO: Add code to properly check if read is in a proper pair based on ISIZE distribution
+                if (proper_pair_check && !plausibly_properly_paired(pre,cur)) {
+                    pre->core.flag &= ~BAM_FPROPER_PAIR;
+                    cur->core.flag &= ~BAM_FPROPER_PAIR;
+                }
+
+                if (do_mate_scoring) {
+                    if ((add_mate_score(pre, cur) == -1) || (add_mate_score(cur, pre) == -1)) {
+                        fprintf(samtools_stderr, "[bam_mating_core] ERROR: unable to add mate score.\n");
+                        goto fail;
+                    }
+                }
+
+                // Write out result
+                if ( !remove_reads ) {
+                    if (sam_write1(out, header, pre) < 0) goto write_fail;
+                    if (sam_write1(out, header, cur) < 0) goto write_fail;
+                } else {
+                    // If we have to remove reads make sure we do it in a way that doesn't create orphans with bad flags
+                    if(pre->core.flag&BAM_FUNMAP) cur->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                    if(cur->core.flag&BAM_FUNMAP) pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                    if(!(pre->core.flag&BAM_FUNMAP)) {
+                        if (sam_write1(out, header, pre) < 0) goto write_fail;
+                    }
+                    if(!(cur->core.flag&BAM_FUNMAP)) {
+                        if (sam_write1(out, header, cur) < 0) goto write_fail;
+                    }
+                }
+                has_prev = 0;
+            } else { // unpaired?  clear bad info and write it out
+                pre->core.mtid = -1; pre->core.mpos = -1; pre->core.isize = 0;
+                pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+                if ( !remove_reads || !(pre->core.flag&BAM_FUNMAP) ) {
+                    if (sam_write1(out, header, pre) < 0) goto write_fail;
+                }
+            }
+        } else has_prev = 1;
+        curr = 1 - curr;
+        pre_end = cur_end;
+    }
+    if (result < -1) goto read_fail;
+    if (has_prev && !remove_reads) { // If we still have a BAM in the buffer it must be unpaired
+        bam1_t *pre = b[1-curr];
+        if (pre->core.tid < 0 || pre->core.pos < 0 || pre->core.flag&BAM_FUNMAP) { // If unmapped
+            pre->core.flag |= BAM_FUNMAP;
+            pre->core.tid = -1;
+            pre->core.pos = -1;
+        }
+        pre->core.mtid = -1; pre->core.mpos = -1; pre->core.isize = 0;
+        pre->core.flag &= ~(BAM_FPAIRED|BAM_FMREVERSE|BAM_FPROPER_PAIR);
+
+        if (sam_write1(out, header, pre) < 0) goto write_fail;
+    }
+    sam_hdr_destroy(header);
+    bam_destroy1(b[0]);
+    bam_destroy1(b[1]);
+    ks_free(&str);
+    return 0;
+
+ read_fail:
+    print_error("fixmate", "Couldn't read from input file");
+    goto fail;
+
+ write_fail:
+    print_error_errno("fixmate", "Couldn't write to output file");
+ fail:
+    sam_hdr_destroy(header);
+    bam_destroy1(b[0]);
+    bam_destroy1(b[1]);
+    ks_free(&str);
+    return 1;
+}
+
+void usage(FILE* where)
+{
+    fprintf(where,
+"Usage: samtools fixmate <in.nameSrt.bam> <out.nameSrt.bam>\n"
+"Options:\n"
+"  -r           Remove unmapped reads and secondary alignments\n"
+"  -p           Disable FR proper pair check\n"
+"  -c           Add template cigar ct tag\n"
+"  -m           Add mate score tag\n"
+"  -u           Uncompressed output\n"
+"  -z, --sanitize FLAG[,FLAG]\n"
+"               Sanitize alignment fields [defaults to all types]\n"
+"  --no-PG      do not add a PG line\n");
+
+    sam_global_opt_help(where, "-.O..@-.");
+
+    fprintf(where,
+"\n"
+"As elsewhere in samtools, use '-' as the filename for stdin/samtools_stdout. The input\n"
+"file must be grouped by read name (e.g. sorted by name). Coordinated sorted\n"
+"input is not accepted.\n");
+}
+
+int bam_mating(int argc, char *argv[])
+{
+    htsThreadPool p = {NULL, 0};
+    samFile *in = NULL, *out = NULL;
+    int c, remove_reads = 0, proper_pair_check = 1, add_ct = 0, res = 1,
+        mate_score = 0, no_pg = 0, sanitize_flags = FIX_ALL;
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    char wmode[4] = {'w', 'b', 0, 0};
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+    char *arg_list = NULL;
+
+    // parse args
+    if (argc == 1) { usage(samtools_stdout); return 0; }
+    while ((c = getopt_long(argc, argv, "rpcmO:@:uz:", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'r': remove_reads = 1; break;
+        case 'p': proper_pair_check = 0; break;
+        case 'c': add_ct = 1; break;
+        case 'm': mate_score = 1; break;
+        case 'u': wmode[2] = '0'; break;
+        case 1: no_pg = 1; break;
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?': usage(samtools_stderr); goto fail;
+        case 'z':
+            if ((sanitize_flags = bam_sanitize_options(optarg)) < 0)
+                samtools_exit(1);
+            break;
+        }
+    }
+    if (optind+1 >= argc) { usage(samtools_stderr); goto fail; }
+
+    if (!no_pg && !(arg_list =  stringify_argv(argc+1, argv-1)))
+        goto fail;
+
+    // init
+    if ((in = sam_open_format(argv[optind], "rb", &ga.in)) == NULL) {
+        print_error_errno("fixmate", "cannot open input file");
+        goto fail;
+    }
+    sam_open_mode(wmode+1, argv[optind+1], NULL);
+    if ((out = sam_open_format(argv[optind+1], wmode, &ga.out)) == NULL) {
+        print_error_errno("fixmate", "cannot open output file");
+        goto fail;
+    }
+
+    if (ga.nthreads > 0) {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            fprintf(samtools_stderr, "Error creating thread pool\n");
+            goto fail;
+        }
+        hts_set_opt(in,  HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(out, HTS_OPT_THREAD_POOL, &p);
+    }
+
+    // run
+    res = bam_mating_core(in, out, remove_reads, proper_pair_check, add_ct,
+                          mate_score, arg_list, no_pg, sanitize_flags);
+
+    // cleanup
+    sam_close(in);
+    if (sam_close(out) < 0) {
+        fprintf(samtools_stderr, "[bam_mating] error while closing output file\n");
+        res = 1;
+    }
+
+    if (p.pool) hts_tpool_destroy(p.pool);
+    free(arg_list);
+    sam_global_args_free(&ga);
+    return res;
+
+ fail:
+    if (in) sam_close(in);
+    if (out) sam_close(out);
+    if (p.pool) hts_tpool_destroy(p.pool);
+    free(arg_list);
+    sam_global_args_free(&ga);
+    return 1;
+}
+
+

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_md.c.pysam.c

@@ -0,0 +1,534 @@
+#include "samtools.pysam.h"
+
+/*  bam_md.c -- calmd subcommand.
+
+    Copyright (C) 2009-2011, 2014-2015, 2019-2020, 2022 Genome Research Ltd.
+    Portions copyright (C) 2009-2011 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <assert.h>
+#include "htslib/faidx.h"
+#include "htslib/sam.h"
+#include "htslib/kstring.h"
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include "samtools.h"
+
+#define USE_EQUAL 1
+#define DROP_TAG  2
+#define BIN_QUAL  4
+#define UPDATE_NM 8
+#define UPDATE_MD 16
+#define HASH_QNM  32
+
+typedef struct cached_ref_entry {
+    char *ref;
+    hts_pos_t len;
+} cached_ref_entry;
+
+typedef struct ref_cache {
+    cached_ref_entry *refs;
+    char *last_ref;
+    hts_pos_t last_len;
+    int nref;
+    int last_tid;
+} ref_cache;
+
+int bam_aux_drop_other(bam1_t *b, uint8_t *s);
+
+static int bam_fillmd1_core(const char *ref_name, bam1_t *b, char *ref,
+                            hts_pos_t ref_len, int flag, int max_nm,
+                            int quiet_mode, uint32_t *skipped)
+{
+    uint8_t *seq = bam_get_seq(b);
+    uint32_t *cigar = bam_get_cigar(b);
+    bam1_core_t *c = &b->core;
+    int i, qpos, matched = 0;
+    hts_pos_t rpos;
+    kstring_t str = KS_INITIALIZE;
+    int32_t old_nm_i = -1, nm = 0;
+    uint32_t err = 0;
+
+    if (c->l_qseq == 0) {
+        if (!quiet_mode) {
+            if (ref_name) {
+                fprintf(samtools_stderr, "[bam_fillmd1] no sequence in alignment "
+                        "record for '%s' at %s:%"PRIhts_pos", skipped\n",
+                        bam_get_qname(b), ref_name, c->pos + 1);
+            } else {
+                fprintf(samtools_stderr, "[bam_fillmd1] no sequence in alignment "
+                        "record for '%s', skipped", bam_get_qname(b));
+            }
+        }
+        if (skipped) (*skipped)++;
+        return 0;
+    }
+
+    for (i = qpos = 0, rpos = c->pos; i < c->n_cigar; ++i) {
+        int j, oplen = cigar[i]>>4, op = cigar[i]&0xf;
+        if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
+            for (j = 0; j < oplen; ++j) {
+                int c1, c2, z = qpos + j;
+                if (rpos+j >= ref_len || z >= c->l_qseq || ref[rpos+j] == '\0')
+                    break; // out of bounds
+                c1 = bam_seqi(seq, z);
+                c2 = seq_nt16_table[(uint8_t)ref[rpos+j]];
+                if ((c1 == c2 && c1 != 15 && c2 != 15) || c1 == 0) { // a match
+                    if (flag&USE_EQUAL) seq[z/2] &= (z&1)? 0xf0 : 0x0f;
+                    ++matched;
+                } else {
+                    err |= kputw(matched, &str) < 0;
+                    err |= kputc(toupper(ref[rpos+j]), &str) < 0;
+                    matched = 0; ++nm;
+                }
+            }
+            if (j < oplen) break;
+            rpos += oplen; qpos += oplen;
+        } else if (op == BAM_CDEL) {
+            err |= kputw(matched, &str) < 0;
+            err |= kputc('^', &str) < 0;
+            for (j = 0; j < oplen; ++j) {
+                if (rpos+j >= ref_len || ref[rpos+j] == '\0') break;
+                err |= kputc(toupper(ref[rpos+j]), &str) < 0;
+            }
+            matched = 0;
+            rpos += j; nm += j;
+            if (j < oplen) break;
+        } else if (op == BAM_CINS || op == BAM_CSOFT_CLIP) {
+            qpos += oplen;
+            if (op == BAM_CINS) nm += oplen;
+        } else if (op == BAM_CREF_SKIP) {
+            rpos += oplen;
+        }
+    }
+    err |= kputw(matched, &str) < 0;
+    if (err) {
+        print_error_errno("calmd", "Couldn't build new MD string");
+        goto fail;
+    }
+    // apply max_nm
+    if (max_nm > 0 && nm >= max_nm) {
+        for (i = qpos = 0, rpos = c->pos; i < c->n_cigar; ++i) {
+            int j, oplen = cigar[i]>>4, op = cigar[i]&0xf;
+            if (op == BAM_CMATCH || op == BAM_CEQUAL || op == BAM_CDIFF) {
+                for (j = 0; j < oplen; ++j) {
+                    int c1, c2, z = qpos + j;
+                    if (rpos+j >= ref_len || z >= c->l_qseq || ref[rpos+j] == '\0')
+                        break; // out of bounds
+                    c1 = bam_seqi(seq, z);
+                    c2 = seq_nt16_table[(uint8_t)ref[rpos+j]];
+                    if ((c1 == c2 && c1 != 15 && c2 != 15) || c1 == 0) { // a match
+                        seq[z/2] |= (z&1)? 0x0f : 0xf0;
+                        bam_get_qual(b)[z] = 0;
+                    }
+                }
+                if (j < oplen) break;
+                rpos += oplen; qpos += oplen;
+            } else if (op == BAM_CDEL || op == BAM_CREF_SKIP) rpos += oplen;
+            else if (op == BAM_CINS || op == BAM_CSOFT_CLIP) qpos += oplen;
+        }
+    }
+    // update NM
+    if ((flag & UPDATE_NM) && !(c->flag & BAM_FUNMAP)) {
+        uint8_t *old_nm = bam_aux_get(b, "NM");
+        if (old_nm) old_nm_i = bam_aux2i(old_nm);
+        if (!old_nm) {
+            if (bam_aux_append(b, "NM", 'i', 4, (uint8_t*)&nm) < 0)
+                goto aux_fail;
+        }
+        else if (nm != old_nm_i) {
+            if (!quiet_mode) {
+                fprintf(samtools_stderr, "[bam_fillmd1] different NM for read '%s': %d -> %d\n", bam_get_qname(b), old_nm_i, nm);
+            }
+            if (bam_aux_del(b, old_nm) < 0) goto aux_fail;
+            if (bam_aux_append(b, "NM", 'i', 4, (uint8_t*)&nm) < 0)
+                goto aux_fail;
+        }
+    }
+    // update MD
+    if ((flag & UPDATE_MD) && !(c->flag & BAM_FUNMAP)) {
+        uint8_t *old_md = bam_aux_get(b, "MD");
+        if (!old_md) {
+            if (bam_aux_append(b, "MD", 'Z', str.l + 1, (uint8_t*)str.s) < 0)
+                goto aux_fail;
+        } else {
+            int is_diff = 0;
+            if (strlen((char*)old_md+1) == str.l) {
+                for (i = 0; i < str.l; ++i)
+                    if (toupper(old_md[i+1]) != toupper(str.s[i]))
+                        break;
+                if (i < str.l) is_diff = 1;
+            } else is_diff = 1;
+            if (is_diff) {
+                if (!quiet_mode) {
+                    fprintf(samtools_stderr, "[bam_fillmd1] different MD for read '%s': '%s' -> '%s'\n", bam_get_qname(b), old_md+1, str.s);
+                }
+                if (bam_aux_del(b, old_md) < 0) goto aux_fail;
+                if (bam_aux_append(b, "MD", 'Z', str.l + 1, (uint8_t*)str.s) < 0)
+                    goto aux_fail;
+            }
+        }
+    }
+
+    // drop all tags but RG
+    if (flag&DROP_TAG) {
+        uint8_t *q = bam_aux_get(b, "RG");
+        bam_aux_drop_other(b, q);
+    }
+    // reduce the resolution of base quality
+    if (flag&BIN_QUAL) {
+        uint8_t *qual = bam_get_qual(b);
+        for (i = 0; i < b->core.l_qseq; ++i)
+            if (qual[i] >= 3) qual[i] = qual[i]/10*10 + 7;
+    }
+
+    free(str.s);
+    return 0;
+
+ aux_fail:
+    if (errno == ENOMEM) {
+        print_error("calmd", "Couldn't add aux tag (too long)");
+    } else if (errno == EINVAL) {
+        print_error("calmd", "Corrupt aux data");
+    } else {
+        print_error_errno("calmd", "Couldn't add aux tag");
+    }
+ fail:
+    free(str.s);
+    return -1;
+}
+
+int bam_fillmd1(bam1_t *b, char *ref, int flag, int quiet_mode)
+{
+    return bam_fillmd1_core(NULL, b, ref, INT_MAX, flag, 0, quiet_mode, NULL);
+}
+
+// Get a new reference sequence.
+// For position-sorted inputs, the previous reference should never be
+// needed again and can be discarded to save memory.  For other orderings,
+// references are stored in a cache in case they're required in the future.
+// The caching mode is turned on if the requested  tid is less than the last
+// one used, indicating the file ordering doesn't match the sequence dictionary.
+static int get_ref(faidx_t *fai, sam_hdr_t *header, ref_cache *cache,
+                   int tid, char **ref_out, const char **ref_name_out,
+                   hts_pos_t *len_out)
+{
+    char *ref = NULL;
+    const char *ref_name;
+    hts_pos_t len = 0;
+
+    // This should only be called when tid changes
+    assert(tid != cache->last_tid);
+
+    // Array lookup, should be fast
+    ref_name = sam_hdr_tid2name(header, tid);
+    *ref_name_out = ref_name;
+
+    // Return a cached entry, if available
+    if (cache->refs && tid >= 0 && tid < cache->nref
+        && cache->refs[tid].ref) {
+        assert(cache->last_ref == NULL);
+        *ref_out = cache->refs[tid].ref;
+        *len_out = cache->refs[tid].len;
+        cache->last_tid = tid;
+        return 0;
+    }
+
+    // Try to get the reference
+    if (ref_name)
+        ref = fai_fetch64(fai, ref_name, &len);
+
+    if (!ref) {
+        // Historically, calmd doesn't worry too much about missing refs
+        *ref_out = NULL;
+        *len_out = 0;
+        return 0;
+    }
+
+    if (!cache->refs && cache->last_tid > tid) {
+        // Going backwards throught the list of tids implies
+        // a non-position-ordered file, so turn on caching mode
+        cache->nref = sam_hdr_nref(header);
+        if (cache->nref < 0) {
+            print_error("calmd", "couldn't get number of refs from header");
+            return -1;
+        }
+        if (cache->nref > 0) {
+            cache->refs = calloc(cache->nref, sizeof(cache->refs[0]));
+            if (!cache->refs) {
+                print_error_errno("calmd",
+                                  "couldn't allocate reference cache");
+                return -1;
+            }
+            // Add the reference we already have as the first entry
+            if (cache->last_tid >= 0 && cache->last_tid < cache->nref) {
+                cache->refs[cache->last_tid].ref = cache->last_ref;
+                cache->refs[cache->last_tid].len = cache->last_len;
+            } else {
+                free(cache->last_ref);
+            }
+            cache->last_ref = NULL;
+        }
+    }
+
+    if (cache->refs) {
+        assert(cache->last_ref == NULL);  // Shouldn't be set when caching
+        // Add the new reference to the cache
+        if (tid >= 0 && tid < cache->nref) {
+            cache->refs[tid].ref = ref;
+            cache->refs[tid].len = len;
+        }
+    } else {
+        // Streaming mode - free the last ref and replace it with this one
+        free(cache->last_ref);
+        cache->last_ref = ref;
+        cache->last_len = len;
+    }
+
+    *ref_out = ref;
+    *len_out = len;
+    cache->last_tid = tid;
+    return 0;
+}
+
+static void refs_destroy(ref_cache *cache) {
+    if (cache->refs) {
+        int i;
+        assert(cache->last_ref == NULL);
+        for (i = 0; i < cache->nref; i++)
+            free(cache->refs[i].ref);
+        free(cache->refs);
+    } else {
+        free(cache->last_ref);
+    }
+}
+
+int calmd_usage() {
+    fprintf(samtools_stderr,
+"Usage: samtools calmd [-eubrAESQ] <aln.bam> <ref.fasta>\n"
+"Options:\n"
+"  -e       change identical bases to '='\n"
+"  -u       uncompressed BAM output (for piping)\n"
+"  -b       compressed BAM output\n"
+"  -S       ignored (input format is auto-detected)\n"
+"  -A       modify the quality string\n"
+"  -Q       use quiet mode to output less debug info to samtools_stdout\n"
+"  -r       compute the BQ tag (without -A) or cap baseQ by BAQ (with -A)\n"
+"  -E       extended BAQ for better sensitivity but lower specificity\n"
+"  --no-PG  do not add a PG line\n");
+
+    sam_global_opt_help(samtools_stderr, "-....@-.");
+    return 1;
+}
+
+int bam_fillmd(int argc, char *argv[])
+{
+    int c, flt_flag, ret, is_bam_out, is_uncompressed, max_nm, is_realn, capQ, baq_flag, quiet_mode, no_pg = 0;
+    hts_pos_t len = 0;
+    htsThreadPool p = {NULL, 0};
+    samFile *fp = NULL, *fpout = NULL;
+    sam_hdr_t *header = NULL;
+    faidx_t *fai = NULL;
+    char *ref = NULL, mode_w[8], *ref_file, *arg_list = NULL;
+    ref_cache refs = { NULL, NULL, 0, 0, -2 };
+    const char *ref_name = NULL;
+    bam1_t *b = NULL;
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    uint32_t skipped = 0;
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 0, 0, 0,'@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+
+    flt_flag = UPDATE_NM | UPDATE_MD;
+    is_bam_out = is_uncompressed = is_realn = max_nm = capQ = baq_flag = quiet_mode = 0;
+    strcpy(mode_w, "w");
+    while ((c = getopt_long(argc, argv, "EqQreuNhbSC:n:Ad@:", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'r': is_realn = 1; break;
+        case 'e': flt_flag |= USE_EQUAL; break;
+        case 'd': flt_flag |= DROP_TAG; break;
+        case 'q': flt_flag |= BIN_QUAL; break;
+        case 'h': flt_flag |= HASH_QNM; break;
+        case 'N': flt_flag &= ~(UPDATE_MD|UPDATE_NM); break;
+        case 'b': is_bam_out = 1; break;
+        case 'u': is_uncompressed = is_bam_out = 1; break;
+        case 'S': break;
+        case 'n': max_nm = atoi(optarg); break;
+        case 'C': capQ = atoi(optarg); break;
+        case 'A': baq_flag |= 1; break;
+        case 'E': baq_flag |= 2; break;
+        case 'Q': quiet_mode = 1; break;
+        case 1: no_pg = 1; break;
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            fprintf(samtools_stderr, "[bam_fillmd] unrecognized option '-%c'\n\n", c);
+            /* else fall-through */
+        case '?': return calmd_usage();
+        }
+    }
+    if (is_bam_out) strcat(mode_w, "b");
+    else strcat(mode_w, "h");
+    if (is_uncompressed) strcat(mode_w, "0");
+    if (optind + (ga.reference == NULL) >= argc)
+        return calmd_usage();
+    fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (fp == NULL) {
+        print_error_errno("calmd", "Failed to open input file '%s'", argv[optind]);
+        return 1;
+    }
+
+    if (!no_pg && !(arg_list = stringify_argv(argc+1, argv-1))) {
+        print_error("calmd", "failed to create arg_list");
+        return 1;
+    }
+
+    header = sam_hdr_read(fp);
+    if (header == NULL || sam_hdr_nref(header) == 0) {
+        // NB: if we have no SQ headers but have aligned data, then this will
+        // be caught during processing with e.g.
+        // "[E::sam_parse1] no SQ lines present in the header"
+        fprintf(samtools_stderr, "[bam_fillmd] warning: input SAM does not have "
+                "header, performing a no-op.\n");
+    }
+
+    fpout = sam_open_format(samtools_stdout_fn, mode_w, &ga.out);
+    if (fpout == NULL) {
+        print_error_errno("calmd", "Failed to open output");
+        goto fail;
+    }
+    if (!no_pg && sam_hdr_add_pg(header, "samtools",
+                                 "VN", samtools_version(),
+                                 arg_list ? "CL": NULL,
+                                 arg_list ? arg_list : NULL,
+                                 NULL)) {
+        print_error("calmd", "failed to add PG line to header");
+        goto fail;
+    }
+    if (sam_hdr_write(fpout, header) < 0) {
+        print_error_errno("calmd", "Failed to write sam header");
+        goto fail;
+    }
+
+    if (ga.nthreads > 0) {
+        if (!(p.pool = hts_tpool_init(ga.nthreads))) {
+            fprintf(samtools_stderr, "Error creating thread pool\n");
+            goto fail;
+        }
+        hts_set_opt(fp,    HTS_OPT_THREAD_POOL, &p);
+        hts_set_opt(fpout, HTS_OPT_THREAD_POOL, &p);
+    }
+
+    ref_file = argc > optind + 1 ? argv[optind+1] : ga.reference;
+    fai = fai_load(ref_file);
+
+    if (!fai) {
+        print_error_errno("calmd", "Failed to open reference file '%s'", ref_file);
+        goto fail;
+    }
+
+    b = bam_init1();
+    if (!b) {
+        fprintf(samtools_stderr, "[bam_fillmd] Failed to allocate bam struct\n");
+        goto fail;
+    }
+    while ((ret = sam_read1(fp, header, b)) >= 0) {
+        if (b->core.tid >= 0) {
+            if (refs.last_tid != b->core.tid) {
+                if (get_ref(fai, header, &refs, b->core.tid,
+                            &ref, &ref_name, &len) < 0) {
+                    goto fail;
+                }
+                if (ref == 0) { // FIXME: Should this always be fatal?
+                    fprintf(samtools_stderr, "[bam_fillmd] fail to find sequence '%s' in the reference.\n",
+                            ref_name ? ref_name : "(unknown)");
+                    if (is_realn || capQ > 10) goto fail; // Would otherwise crash
+                }
+            }
+            if (is_realn) {
+                if (sam_prob_realn(b, ref, len, baq_flag) < -3) {
+                    print_error_errno("calmd", "BAQ alignment failed");
+                    goto fail;
+                }
+            }
+            if (capQ > 10) {
+                int q = sam_cap_mapq(b, ref, len, capQ);
+                if (b->core.qual > q) b->core.qual = q;
+            }
+            if (ref) {
+                if (bam_fillmd1_core(ref_name, b, ref, len, flt_flag, max_nm,
+                                     quiet_mode, &skipped) < 0)
+                    goto fail;
+            }
+        }
+        if (sam_write1(fpout, header, b) < 0) {
+            print_error_errno("calmd", "failed to write to output file");
+            goto fail;
+        }
+    }
+    if (ret < -1) {
+        fprintf(samtools_stderr, "[bam_fillmd] Error reading input.\n");
+        goto fail;
+    }
+
+    if (skipped) {
+        fprintf(samtools_stderr, "[calmd] Warning: %"PRIu32" records skipped due "
+                "to no query sequence\n",
+                skipped);
+    }
+
+    bam_destroy1(b);
+    sam_hdr_destroy(header);
+
+    free(arg_list);
+    refs_destroy(&refs);
+    fai_destroy(fai);
+    sam_close(fp);
+    if (sam_close(fpout) < 0) {
+        fprintf(samtools_stderr, "[bam_fillmd] error when closing output file\n");
+        return 1;
+    }
+    if (p.pool) hts_tpool_destroy(p.pool);
+
+    return 0;
+
+ fail:
+    free(arg_list);
+    refs_destroy(&refs);
+    if (b) bam_destroy1(b);
+    if (header) sam_hdr_destroy(header);
+    if (fai) fai_destroy(fai);
+    if (fp) sam_close(fp);
+    if (fpout) sam_close(fpout);
+    if (p.pool) hts_tpool_destroy(p.pool);
+
+    return 1;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_quickcheck.c

@@ -0,0 +1,190 @@
+/*  bam_quickcheck.c -- quickcheck subcommand.
+
+    Copyright (C) 2015-2017 Genome Research Ltd.
+
+    Author: Joshua C. Randall <jcrandall@alum.mit.edu>
+
+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.  */
+
+#include <config.h>
+
+#include <htslib/hts.h>
+#include <htslib/sam.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* File status flags (zero means OK). It's possible for more than one to be
+ * set on a single file.   The final exit status is the bitwise-or of the
+ * status of all the files. */
+#define QC_FAIL_OPEN     2
+#define QC_NOT_SEQUENCE  4
+#define QC_BAD_HEADER    8
+#define QC_NO_EOF_BLOCK 16
+#define QC_FAIL_CLOSE   32
+
+static void usage_quickcheck(FILE *write_to)
+{
+    fprintf(write_to,
+"Usage: samtools quickcheck [options] <input> [...]\n"
+"Options:\n"
+"  -v              verbose output (repeat for more verbosity)\n"
+"  -q              suppress warning messages\n"
+"  -u              unmapped input (do not require targets in header)\n"
+"\n"
+"Notes:\n"
+"\n"
+"1. By default quickcheck will emit a warning message if and only if a file\n"
+"   fails the checks, in which case the exit status is non-zero.  Under normal\n"
+"   behaviour with valid data it will be silent and has a zero exit status.\n"
+"   The warning messages are purely for manual inspection and should not be \n"
+"   parsed by scripts.\n"
+"\n"
+"2. In order to use this command programmatically, you should check its exit\n"
+"   status.  One way to use quickcheck might be as a check that all BAM files in\n"
+"   a directory are okay:\n"
+"\n"
+"\tsamtools quickcheck *.bam && echo 'all ok' \\\n"
+"\t   || echo 'fail!'\n"
+"\n"
+"   The first level of verbosity lists only files that fail to stdout.\n"
+"   To obtain a parsable list of files that have failed, use this option:\n"
+"\n"
+"\tsamtools quickcheck -qv *.bam > bad_bams.fofn \\\n"
+"\t   && echo 'all ok' \\\n"
+"\t   || echo 'some files failed check, see bad_bams.fofn'\n"
+    );
+}
+
+#define QC_ERR(state, v, msg, arg1)                                     \
+    file_state |= (state);                                              \
+    if (!quiet || verbose >= (v)) fprintf(stderr, (msg), (arg1))
+
+int main_quickcheck(int argc, char** argv)
+{
+    int verbose = 0, quiet = 0, unmapped = 0;
+    hts_verbose = 0;
+
+    const char* optstring = "vqu";
+    int opt;
+    while ((opt = getopt(argc, argv, optstring)) != -1) {
+        switch (opt) {
+        case 'u':
+            unmapped = 1;
+            break;
+        case 'v':
+            verbose++;
+            break;
+        case 'q':
+            quiet = 1;
+            break;
+        default:
+            usage_quickcheck(stderr);
+            return 1;
+        }
+    }
+
+    argc -= optind;
+    argv += optind;
+
+    if (argc < 1) {
+        usage_quickcheck(stdout);
+        return 1;
+    }
+
+    if (verbose >= 2) {
+        fprintf(stderr, "verbosity set to %d\n", verbose);
+    }
+
+    if (verbose >= 4) {
+        hts_verbose = 3;
+    }
+
+    int ret = 0;
+    int i;
+
+    for (i = 0; i < argc; i++) {
+        char* fn = argv[i];
+        int file_state = 0;
+
+        if (verbose >= 3) fprintf(stderr, "checking %s\n", fn);
+
+        // attempt to open
+        htsFile *hts_fp = hts_open(fn, "r");
+        if (hts_fp == NULL) {
+            QC_ERR(QC_FAIL_OPEN, 2, "%s could not be opened for reading.\n", fn);
+        }
+        else {
+            if (verbose >= 3) fprintf(stderr, "opened %s\n", fn);
+            // make sure we have sequence data
+            const htsFormat *fmt = hts_get_format(hts_fp);
+            if (fmt->category != sequence_data ) {
+                QC_ERR(QC_NOT_SEQUENCE, 2, "%s was not identified as sequence data.\n", fn);
+            }
+            else {
+                if (verbose >= 3) fprintf(stderr, "%s is sequence data\n", fn);
+                // check header
+                sam_hdr_t *header = sam_hdr_read(hts_fp);
+                if (header == NULL) {
+                    QC_ERR(QC_BAD_HEADER, 2, "%s caused an error whilst reading its header.\n", fn);
+                } else {
+                    if (!unmapped && sam_hdr_nref(header) <= 0) {
+                        QC_ERR(QC_BAD_HEADER, 2, "%s had no targets in header.\n", fn);
+                    }
+                    else {
+                        if (verbose >= 3) fprintf(stderr, "%s has %d targets in header.\n", fn, sam_hdr_nref(header));
+                    }
+                    sam_hdr_destroy(header);
+                }
+            }
+            // check EOF on formats that support this
+            int ret;
+            if ((ret = hts_check_EOF(hts_fp)) < 0) {
+                QC_ERR(QC_NO_EOF_BLOCK, 2, "%s caused an error whilst checking for EOF block.\n", fn);
+           }
+            else {
+                switch (ret) {
+                    case 0:
+                        QC_ERR(QC_NO_EOF_BLOCK, 2, "%s was missing EOF block when one should be present.\n", fn);
+                        break;
+                    case 1:
+                        if (verbose >= 3) fprintf(stderr, "%s has good EOF block.\n", fn);
+                        break;
+                    case 2:
+                        if (verbose >= 3) fprintf(stderr, "%s cannot be checked for EOF block as it is not seekable.\n", fn);
+                        break;
+                    case 3:
+                        if (verbose >= 3) fprintf(stderr, "%s cannot be checked for EOF block because its filetype does not contain one.\n", fn);
+                        break;
+                }
+            }
+
+            if (hts_close(hts_fp) < 0) {
+                QC_ERR(QC_FAIL_CLOSE, 2, "%s did not close cleanly.\n", fn);
+            }
+        }
+
+        if (file_state > 0 && verbose >= 1) {
+            fprintf(stdout, "%s\n", fn);
+        }
+        ret |= file_state;
+    }
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_reheader.c

@@ -0,0 +1,634 @@
+/*  bam_reheader.c -- reheader subcommand.
+
+    Copyright (C) 2010 Broad Institute.
+    Copyright (C) 2012-2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <getopt.h>
+#include <unistd.h>
+
+#include "htslib/bgzf.h"
+#include "htslib/sam.h"
+#include "htslib/hfile.h"
+#include "htslib/cram.h"
+#include "samtools.h"
+
+#define BUF_SIZE 0x10000
+
+/*
+ * Reads a file and outputs a new BAM file to fd with 'h' replaced as
+ * the header.    No checks are made to the validity.
+ */
+int bam_reheader(BGZF *in, sam_hdr_t *h, int fd,
+                 const char *arg_list, int no_pg, int skip_header)
+{
+    BGZF *fp = NULL;
+    ssize_t len;
+    uint8_t *buf = NULL;
+    sam_hdr_t *tmp;
+    if (!h)
+        return -1;
+
+    if (in->is_write) return -1;
+    buf = malloc(BUF_SIZE);
+    if (!buf) {
+        fprintf(stderr, "Out of memory\n");
+        return -1;
+    }
+
+    if (!skip_header) {
+        if ((tmp = bam_hdr_read(in)) == NULL) {
+            fprintf(stderr, "Couldn't read header\n");
+            goto fail;
+        }
+        sam_hdr_destroy(tmp);
+    }
+
+    fp = bgzf_fdopen(fd, "w");
+    if (!fp) {
+        print_error_errno("reheader", "Couldn't open output file");
+        goto fail;
+    }
+
+    if (!no_pg && sam_hdr_add_pg(h, "samtools",
+                           "VN", samtools_version(),
+                           arg_list ? "CL": NULL,
+                           arg_list ? arg_list : NULL,
+                           NULL) != 0)
+            goto fail;
+
+    if (bam_hdr_write(fp, h) < 0) {
+        print_error_errno("reheader", "Couldn't write header");
+        goto fail;
+    }
+    if (in->block_offset < in->block_length) {
+        if (bgzf_write(fp, (char *)in->uncompressed_block + in->block_offset, in->block_length - in->block_offset) < 0) goto write_fail;
+        if (bgzf_flush(fp) < 0) goto write_fail;
+    }
+    while ((len = bgzf_raw_read(in, buf, BUF_SIZE)) > 0) {
+        if (bgzf_raw_write(fp, buf, len) < 0) goto write_fail;
+    }
+    if (len < 0) {
+        fprintf(stderr, "[%s] Error reading input file\n", __func__);
+        goto fail;
+    }
+    free(buf);
+    fp->block_offset = in->block_offset = 0;
+    if (bgzf_close(fp) < 0) {
+        fprintf(stderr, "[%s] Error closing output file\n", __func__);
+        return -1;
+    }
+    return 0;
+
+ write_fail:
+    print_error_errno("reheader", "Error writing to output file");
+ fail:
+    bgzf_close(fp);
+    free(buf);
+    return -1;
+}
+
+/*
+ * Reads a file and outputs a new CRAM file to stdout with 'h'
+ * replaced as the header.  No checks are made to the validity.
+ *
+ * FIXME: error checking
+ */
+int cram_reheader(cram_fd *in, sam_hdr_t *h, const char *arg_list, int no_pg)
+{
+    htsFile *h_out = hts_open("-", "wc");
+    cram_fd *out = h_out->fp.cram;
+    cram_container *c = NULL;
+    int ret = -1;
+    if (!h)
+        return ret;
+
+    // Match output version number with input file.
+    char vers[99];
+    sprintf(vers, "%d.%d", cram_major_vers(in), cram_minor_vers(in));
+    cram_set_option(out, CRAM_OPT_VERSION, vers);
+
+    // Attempt to fill out a cram->refs[] array from @SQ headers
+    sam_hdr_t *cram_h = sam_hdr_dup(h);
+    if (!cram_h)
+        return -1;
+    cram_fd_set_header(out, cram_h);
+    if (!no_pg && sam_hdr_add_pg(cram_fd_get_header(out), "samtools",
+                           "VN", samtools_version(),
+                           arg_list ? "CL": NULL,
+                           arg_list ? arg_list : NULL,
+                           NULL))
+            goto err;
+
+    if (sam_hdr_write(h_out, cram_h) != 0)
+        goto err;
+    cram_set_option(out, CRAM_OPT_REFERENCE, NULL);
+
+    while ((c = cram_read_container(in))) {
+        int32_t i, num_blocks = cram_container_get_num_blocks(c);
+        if (cram_write_container(out, c) != 0)
+            goto err;
+
+        for (i = 0; i < num_blocks; i++) {
+            cram_block *blk = cram_read_block(in);
+            if (!blk || cram_write_block(out, blk) != 0) {
+                if (blk) cram_free_block(blk);
+                goto err;
+            }
+            cram_free_block(blk);
+        }
+        cram_free_container(c);
+    }
+
+    ret = 0;
+
+ err:
+    if (hts_close(h_out) != 0)
+        ret = -1;
+
+    return ret;
+}
+
+
+
+/*
+ * Reads a version 2 CRAM file and replaces the header in-place,
+ * provided the header is small enough to fit without growing the
+ * entire file.
+ *
+ * Version 2 format has an uncompressed SAM header with multiple nul
+ * termination bytes to permit inline header editing.
+ *
+ * Returns 0 on success;
+ *        -1 on general failure;
+ *        -2 on failure due to insufficient size
+ */
+int cram_reheader_inplace2(cram_fd *fd, sam_hdr_t *h, const char *arg_list,
+                          int no_pg)
+{
+    cram_container *c = NULL;
+    cram_block *b = NULL;
+    sam_hdr_t *cram_h = NULL;
+    off_t start;
+    int ret = -1;
+    if (!h)
+        goto err;
+
+    if (cram_major_vers(fd) < 2 ||
+        cram_major_vers(fd) > 3) {
+        fprintf(stderr, "[%s] unsupported CRAM version %d\n", __func__,
+                cram_major_vers(fd));
+        goto err;
+    }
+
+    cram_h = sam_hdr_dup(h);
+    if (!cram_h)
+        goto err;
+
+    if (!no_pg && sam_hdr_add_pg(cram_h, "samtools", "VN", samtools_version(),
+                                 arg_list ? "CL": NULL,
+                                 arg_list ? arg_list : NULL,
+                                 NULL))
+        goto err;
+
+    int header_len = sam_hdr_length(cram_h);
+    /* Fix M5 strings? Maybe out of scope for this tool */
+
+    // Load the existing header
+    if ((start = hseek(cram_fd_get_fp(fd), 26, SEEK_SET)) != 26)
+        goto err;
+
+    if (!(c = cram_read_container(fd)))
+        goto err;
+
+    // Version 2.1 has a single uncompressed block which is nul
+    // terminated with many nuls to permit growth.
+    //
+    // So load old block and keep all contents identical bar the
+    // header text itself
+    if (!(b = cram_read_block(fd)))
+        goto err;
+
+    if (cram_block_get_uncomp_size(b) < header_len+4) {
+        fprintf(stderr, "New header will not fit. Use non-inplace version (%d > %d)\n",
+                header_len+4, cram_block_get_uncomp_size(b));
+        ret = -2;
+        goto err;
+    }
+
+    cram_block_set_offset(b, 0);   // rewind block
+    int32_put_blk(b, header_len);
+    cram_block_append(b, (void *)sam_hdr_str(cram_h), header_len);
+    // Zero the remaining block
+    memset((char *)cram_block_get_data(b)+cram_block_get_offset(b), 0,
+           cram_block_get_uncomp_size(b) - cram_block_get_offset(b));
+    // Make sure all sizes and byte-offsets are consistent after memset
+    cram_block_set_offset(b, cram_block_get_uncomp_size(b));
+    cram_block_set_comp_size(b, cram_block_get_uncomp_size(b));
+
+    if (hseek(cram_fd_get_fp(fd), start, SEEK_SET) != start)
+        goto err;
+
+    if (cram_write_container(fd, c) == -1)
+        goto err;
+
+    if (cram_write_block(fd, b) == -1)
+        goto err;
+
+    ret = 0;
+ err:
+    if (c) cram_free_container(c);
+    if (b) cram_free_block(b);
+    if (cram_h) sam_hdr_destroy(cram_h);
+
+    return ret;
+}
+
+
+/*
+ * Reads a version 3 CRAM file and replaces the header in-place,
+ * provided the header is small enough to fit without growing the
+ * entire file.
+ *
+ * Version 3 format has a SAM header held as an (optionally)
+ * compressed block within the header container.  Additional
+ * uncompressed blocks or simply unallocated space (the difference
+ * between total block sizes and the container size) are used to
+ * provide room for growth or contraction of the compressed header.
+ *
+ * Returns 0 on success;
+ *        -1 on general failure;
+ *        -2 on failure due to insufficient size
+ */
+int cram_reheader_inplace3(cram_fd *fd, sam_hdr_t *h, const char *arg_list,
+                          int no_pg)
+{
+    cram_container *c = NULL;
+    cram_block *b = NULL;
+    sam_hdr_t *cram_h = NULL;
+    off_t start, sz, end;
+    int container_sz, max_container_sz;
+    char *buf = NULL;
+    int ret = -1;
+    if (!h)
+        goto err;
+
+    if (cram_major_vers(fd) < 2 ||
+        cram_major_vers(fd) > 3) {
+        fprintf(stderr, "[%s] unsupported CRAM version %d\n", __func__,
+                cram_major_vers(fd));
+        goto err;
+    }
+
+    cram_h = sam_hdr_dup(h);
+    if (!cram_h)
+        goto err;
+
+    if (!no_pg && sam_hdr_add_pg(cram_h, "samtools", "VN", samtools_version(),
+                                 arg_list ? "CL": NULL,
+                                 arg_list ? arg_list : NULL,
+                                 NULL))
+        goto err;
+
+    int header_len = sam_hdr_length(cram_h);
+    /* Fix M5 strings? Maybe out of scope for this tool */
+
+    // Find current size of SAM header block
+    if ((start = hseek(cram_fd_get_fp(fd), 26, SEEK_SET)) != 26)
+        goto err;
+
+    if (!(c = cram_read_container(fd)))
+        goto err;
+
+    // +5 allows num_landmarks to increase from 0 to 1 (Cramtools)
+    max_container_sz = cram_container_size(c)+5;
+
+    sz = htell(cram_fd_get_fp(fd)) + cram_container_get_length(c) - start;
+    end = htell(cram_fd_get_fp(fd)) + cram_container_get_length(c);
+
+    // We force 1 block instead of (optionally) 2.  C CRAM
+    // implementations for v3 were writing 1 compressed block followed
+    // by 1 uncompressed block.  However this is tricky to deal with
+    // as changing block sizes can mean the block header also changes
+    // size due to itf8 and variable size integers.
+    //
+    // If we had 1 block, this doesn't change anything.
+    // If we had 2 blocks, the new container header will be smaller by
+    // 1+ bytes, requiring the cram_container_get_length(c) to be larger in value.
+    // However this is an int32 instead of itf8 so the container
+    // header structure stays the same size.  This means we can always
+    // reduce the number of blocks without running into size problems.
+    cram_container_set_num_blocks(c, 1);
+    int32_t *landmark;
+    int32_t num_landmarks;
+    landmark = cram_container_get_landmarks(c, &num_landmarks);
+    if (num_landmarks && landmark) {
+        num_landmarks = 1;
+        landmark[0] = 0;
+    } else {
+        num_landmarks = 0;
+    }
+    cram_container_set_landmarks(c, num_landmarks, landmark);
+
+    buf = malloc(max_container_sz);
+    container_sz = max_container_sz;
+    if (cram_store_container(fd, c, buf, &container_sz) != 0)
+        goto err;
+
+    if (!buf)
+        goto err;
+
+    // Proposed new length, but changing cram_container_get_length(c) may change the
+    // container_sz and thus the remainder (cram_container_get_length(c) itself).
+    cram_container_set_length(c, sz - container_sz);
+
+    int old_container_sz = container_sz;
+    container_sz = max_container_sz;
+    if (cram_store_container(fd, c, buf, &container_sz) != 0)
+        goto err;
+
+    if (old_container_sz != container_sz) {
+        fprintf(stderr, "Quirk of fate makes this troublesome! "
+                "Please use non-inplace version.\n");
+        goto err;
+    }
+
+
+
+    // Version 3.0 supports compressed header
+    b = cram_new_block(FILE_HEADER, 0);
+    int32_put_blk(b, header_len);
+    cram_block_append(b, (void *)sam_hdr_str(cram_h), header_len);
+    cram_block_update_size(b);
+
+    cram_compress_block(fd, b, NULL, -1, 9);
+
+    if (hseek(cram_fd_get_fp(fd), 26, SEEK_SET) != 26)
+        goto err;
+
+    if (cram_block_size(b) > cram_container_get_length(c)) {
+        fprintf(stderr, "New header will not fit. Use non-inplace version"
+                " (%d > %d)\n",
+                (int)cram_block_size(b), cram_container_get_length(c));
+        ret = -2;
+        goto err;
+    }
+
+    if (cram_write_container(fd, c) == -1)
+        goto err;
+
+    if (cram_write_block(fd, b) == -1)
+        goto err;
+
+    // Blank out the remainder
+    int rsz = end - htell(cram_fd_get_fp(fd));
+    assert(rsz >= 0);
+    if (rsz) {
+        char *rem = calloc(1, rsz);
+        ret = hwrite(cram_fd_get_fp(fd), rem, rsz) == rsz ? 0 : -1;
+        free(rem);
+    }
+
+ err:
+    if (c) cram_free_container(c);
+    if (buf) free(buf);
+    if (b) cram_free_block(b);
+    if (cram_h) sam_hdr_destroy(cram_h);
+
+    return ret;
+}
+
+int cram_reheader_inplace(cram_fd *fd, sam_hdr_t *h, const char *arg_list,
+                         int no_pg)
+{
+    switch (cram_major_vers(fd)) {
+    case 2: return cram_reheader_inplace2(fd, h, arg_list, no_pg);
+    case 3: return cram_reheader_inplace3(fd, h, arg_list, no_pg);
+    default:
+        fprintf(stderr, "[%s] unsupported CRAM version %d\n", __func__,
+                cram_major_vers(fd));
+        return -1;
+    }
+}
+
+static void usage(FILE *fp, int ret) {
+    fprintf(fp,
+           "Usage: samtools reheader [-P] in.header.sam in.bam > out.bam\n"
+           "   or  samtools reheader [-P] -i in.header.sam file.cram\n"
+           "   or  samtools reheader -c CMD in.bam\n"
+           "   or  samtools reheader -c CMD in.cram\n"
+           "\n"
+           "Options:\n"
+           "    -P, --no-PG         Do not generate a @PG header line.\n"
+           "    -i, --in-place      Modify the CRAM file directly, if possible.\n"
+           "                        (Defaults to outputting to stdout.)\n"
+           "    -c, --command CMD   Pass the header in SAM format to external program CMD.\n");
+    exit(ret);
+}
+
+static sam_hdr_t* external_reheader(samFile* in, const char* external) {
+    char *command = NULL;
+    sam_hdr_t* h = NULL;
+    sam_hdr_t* ih = sam_hdr_read(in);
+    if (ih == NULL) {
+        fprintf(stderr, "[%s] failed to read the header for '%s'.\n", __func__, in->fn);
+        return NULL;
+    }
+    char tmp_fn[] = "reheaderXXXXXX";
+    int tmp_fd = mkstemp(tmp_fn);
+    if (tmp_fd < 0) {
+        print_error_errno("reheader", "fail to open temp file '%s'", tmp_fn);
+        return NULL;
+    }
+    hFILE* tmp_hf = hdopen(tmp_fd, "w");
+    if (!tmp_hf) {
+        fprintf(stderr, "[%s] failed to convert to hFILE.\n", __func__);
+        goto cleanup;
+    }
+    samFile* tmp_sf = hts_hopen(tmp_hf, tmp_fn, "w");
+    if (!tmp_sf) {
+        fprintf(stderr, "[%s] failed to convert to samFile.\n", __func__);
+        goto cleanup;
+    }
+    if (-1 == sam_hdr_write(tmp_sf, ih)) {
+        fprintf(stderr, "[%s] failed to write the header to the temp file.\n", __func__);
+        goto cleanup;
+    }
+    sam_close(tmp_sf);
+    sam_hdr_destroy(ih);
+    int comm_len = strlen(external) + strlen(tmp_fn) + 8;
+    command = calloc(comm_len, 1);
+    if (!command || snprintf(command, comm_len, "( %s ) < %s", external, tmp_fn) != comm_len - 1) {
+        fprintf(stderr, "[%s] failed to create command string.\n", __func__);
+        goto cleanup;
+    }
+    FILE* nh = popen(command, "r");
+    if (!nh) {
+        print_error_errno("reheader", "[%s] failed to run external command '%s'.\n", __func__, command);
+        goto cleanup;
+    }
+
+    int nh_fd = dup(fileno(nh));
+    if (nh_fd < 0) {
+        fprintf(stderr, "[%s] failed to get the file descriptor.\n", __func__);
+        goto cleanup;
+    }
+    hFILE* nh_hf = hdopen(nh_fd, "r");
+    if (!nh_hf) {
+        fprintf(stderr, "[%s] failed to convert to hFILE.\n", __func__);
+        goto cleanup;
+    }
+    samFile* nh_sf = hts_hopen(nh_hf, tmp_fn, "r");
+    if (!nh_sf) {
+        fprintf(stderr, "[%s] failed to convert to samFile.\n", __func__);
+        goto cleanup;
+    }
+
+    h = sam_hdr_read(nh_sf);
+    sam_close(nh_sf);
+    if (h == NULL) {
+        fprintf(stderr, "[%s] failed to read the header from the temp file.\n", __func__);
+    }
+    int res = pclose(nh);
+    if (res != 0) {
+        if (res < 0) {
+            print_error_errno("reheader",
+                              "Error on closing pipe from command '%s'.\n",
+                              command);
+        } else {
+            print_error("reheader",
+                        "Non-zero exit code returned by command '%s'\n",
+                        command);
+        }
+        if (h) sam_hdr_destroy(h);
+        h = NULL;
+    }
+cleanup:
+    free(command);
+    if (unlink(tmp_fn) != 0) {
+        print_error_errno("reheader", "failed to remove the temp file '%s'", tmp_fn);
+    }
+
+    return h;
+}
+
+int main_reheader(int argc, char *argv[])
+{
+    int inplace = 0, r, no_pg = 0, c, skip_header = 0;
+    sam_hdr_t *h;
+    samFile *in;
+    char *arg_list = NULL, *external = NULL;
+
+    static const struct option lopts[] = {
+        {"help",     no_argument, NULL, 'h'},
+        {"in-place", no_argument, NULL, 'i'},
+        {"no-PG",    no_argument, NULL, 'P'},
+        {"command", required_argument, NULL, 'c'},
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "hiPc:", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'P': no_pg = 1; break;
+        case 'i': inplace = 1; break;
+        case 'c': external = optarg; break;
+        case 'h': usage(stdout, 0); break;
+        default:
+            fprintf(stderr, "Invalid option '%c'\n", c);
+            usage(stderr, 1);
+        }
+    }
+
+    if ((argc - optind != 2 || external) && (argc - optind != 1 || !external))
+        usage(stderr, 1);
+
+    if (!no_pg && !(arg_list = stringify_argv(argc+1, argv-1))) {
+         print_error("reheader", "failed to create arg_list");
+         return 1;
+     }
+
+    if (external) {
+        skip_header = 1;
+        in = sam_open(argv[optind], inplace?"r+":"r");
+        if (in == 0) {
+            print_error_errno("reheader", "fail to open file '%s'", argv[optind]);
+            return 1;
+        }
+
+        h = external_reheader(in, external);
+        if (h == NULL) {
+            fprintf(stderr, "[%s] failed to read the header from '%s'.\n", __func__, external);
+            sam_close(in);
+            return 1;
+        }
+    } else { // read the header from a separate file
+        samFile *fph = sam_open(argv[optind], "r");
+        if (fph == 0) {
+            print_error_errno("reheader", "fail to read the header from '%s'", argv[optind]);
+            return 1;
+        }
+        h = sam_hdr_read(fph);
+        sam_close(fph);
+        if (h == NULL) {
+            fprintf(stderr, "[%s] failed to read the header for '%s'.\n",
+                    __func__, argv[1]);
+            return 1;
+        }
+        in = sam_open(argv[optind+1], inplace?"r+":"r");
+        if (in == 0) {
+            print_error_errno("reheader", "fail to open file '%s'", argv[optind+1]);
+            return 1;
+        }
+    }
+
+    if (hts_get_format(in)->format == bam) {
+        if (inplace) {
+            print_error("reheader", "cannot reheader BAM '%s' in-place", argv[optind+1]);
+            r = -1;
+        } else {
+            r = bam_reheader(in->fp.bgzf, h, fileno(stdout), arg_list, no_pg, skip_header);
+        }
+    } else if (hts_get_format(in)->format == cram) {
+        if (inplace)
+            r = cram_reheader_inplace(in->fp.cram, h, arg_list, no_pg);
+        else
+            r = cram_reheader(in->fp.cram, h, arg_list, no_pg);
+    } else {
+        print_error("reheader", "input file '%s' must be BAM or CRAM", argv[optind+1]);
+        r = -1;
+    }
+
+    if (sam_close(in) != 0)
+        r = -1;
+
+    sam_hdr_destroy(h);
+
+    if (arg_list)
+        free(arg_list);
+
+    return -r;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_rmdup.c.pysam.c

@@ -0,0 +1,327 @@
+#include "samtools.pysam.h"
+
+/*  bam_rmdup.c -- duplicate read detection.
+
+    Copyright (C) 2009, 2015, 2016, 2019 Genome Research Ltd.
+    Portions copyright (C) 2009 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <zlib.h>
+#include <unistd.h>
+#include "htslib/sam.h"
+#include "sam_opts.h"
+#include "samtools.h"
+#include "bam.h" // for bam_get_library
+
+typedef bam1_t *bam1_p;
+
+#include "htslib/khash.h"
+KHASH_SET_INIT_STR(name)
+KHASH_MAP_INIT_INT64(pos, bam1_p)
+
+#define BUFFER_SIZE 0x40000
+
+typedef struct {
+    uint64_t n_checked, n_removed;
+    khash_t(pos) *best_hash;
+} lib_aux_t;
+KHASH_MAP_INIT_STR(lib, lib_aux_t)
+
+typedef struct {
+    int n, max;
+    bam1_t **a;
+} tmp_stack_t;
+
+static inline void stack_insert(tmp_stack_t *stack, bam1_t *b)
+{
+    if (stack->n == stack->max) {
+        stack->max = stack->max? stack->max<<1 : 0x10000;
+        stack->a = (bam1_t**)realloc(stack->a, sizeof(bam1_t*) * stack->max);
+    }
+    stack->a[stack->n++] = b;
+}
+
+static inline int dump_best(tmp_stack_t *stack, samFile *out, sam_hdr_t *hdr)
+{
+    int i;
+    for (i = 0; i != stack->n; ++i) {
+        if (sam_write1(out, hdr, stack->a[i]) < 0) return -1;
+        bam_destroy1(stack->a[i]);
+        stack->a[i] = NULL;
+    }
+    stack->n = 0;
+    return 0;
+}
+
+static inline void clear_stack(tmp_stack_t *stack) {
+    int i;
+    if (!stack->a) return;
+    for (i = 0; i != stack->n; ++i) {
+        bam_destroy1(stack->a[i]);
+    }
+}
+
+static void clear_del_set(khash_t(name) *del_set)
+{
+    khint_t k;
+    for (k = kh_begin(del_set); k < kh_end(del_set); ++k)
+        if (kh_exist(del_set, k))
+            free((char*)kh_key(del_set, k));
+    kh_clear(name, del_set);
+}
+
+static lib_aux_t *get_aux(khash_t(lib) *aux, const char *lib)
+{
+    khint_t k = kh_get(lib, aux, lib);
+    if (k == kh_end(aux)) {
+        int ret;
+        char *p = strdup(lib);
+        lib_aux_t *q;
+        k = kh_put(lib, aux, p, &ret);
+        q = &kh_val(aux, k);
+        q->n_checked = q->n_removed = 0;
+        q->best_hash = kh_init(pos);
+        return q;
+    } else return &kh_val(aux, k);
+}
+
+static void clear_best(khash_t(lib) *aux, int max)
+{
+    khint_t k;
+    for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+        if (kh_exist(aux, k)) {
+            lib_aux_t *q = &kh_val(aux, k);
+            if (kh_size(q->best_hash) >= max)
+                kh_clear(pos, q->best_hash);
+        }
+    }
+}
+
+static inline int sum_qual(const bam1_t *b)
+{
+    int i, q;
+    uint8_t *qual = bam_get_qual(b);
+    for (i = q = 0; i < b->core.l_qseq; ++i) q += qual[i];
+    return q;
+}
+
+int bam_rmdup_core(samFile *in, sam_hdr_t *hdr, samFile *out)
+{
+    bam1_t *b = NULL;
+    int last_tid = -1, last_pos = -1, r;
+    tmp_stack_t stack;
+    khint_t k;
+    khash_t(lib) *aux = NULL;
+    khash_t(name) *del_set = NULL;
+
+    memset(&stack, 0, sizeof(tmp_stack_t));
+    aux = kh_init(lib);
+    del_set = kh_init(name);
+    b = bam_init1();
+    if (!aux || !del_set || !b) {
+        perror(__func__);
+        goto fail;
+    }
+
+    kh_resize(name, del_set, 4 * BUFFER_SIZE);
+    while ((r = sam_read1(in, hdr, b)) >= 0) {
+        bam1_core_t *c = &b->core;
+        if (c->tid != last_tid || last_pos != c->pos) {
+            if (dump_best(&stack, out, hdr) < 0) goto write_fail; // write the result
+            clear_best(aux, BUFFER_SIZE);
+            if (c->tid != last_tid) {
+                clear_best(aux, 0);
+                if (kh_size(del_set)) { // check
+                    fprintf(samtools_stderr, "[bam_rmdup_core] %llu unmatched pairs\n", (long long)kh_size(del_set));
+                    clear_del_set(del_set);
+                }
+                if ((int)c->tid == -1) { // append unmapped reads
+                    if (sam_write1(out, hdr, b) < 0) goto write_fail;
+                    while ((r = sam_read1(in, hdr, b)) >= 0) {
+                        if (sam_write1(out, hdr, b) < 0) goto write_fail;
+                    }
+                    break;
+                }
+                last_tid = c->tid;
+                fprintf(samtools_stderr, "[bam_rmdup_core] processing reference %s...\n", sam_hdr_tid2name(hdr, c->tid));
+            }
+        }
+        if (!(c->flag&BAM_FPAIRED) || (c->flag&(BAM_FUNMAP|BAM_FMUNMAP)) || (c->mtid >= 0 && c->tid != c->mtid)) {
+            if (sam_write1(out, hdr, b) < 0) goto write_fail;
+        } else if (c->isize > 0) { // paired, head
+            uint64_t key = (uint64_t)c->pos<<32 | c->isize;
+            const char *lib;
+            lib_aux_t *q;
+            int ret;
+            lib = bam_get_library(hdr, b);
+            q = lib? get_aux(aux, lib) : get_aux(aux, "\t");
+            ++q->n_checked;
+            k = kh_put(pos, q->best_hash, key, &ret);
+            if (ret < 0) goto fail;
+            if (ret == 0) { // found in best_hash
+                bam1_t *p = kh_val(q->best_hash, k);
+                ++q->n_removed;
+                if (sum_qual(p) < sum_qual(b)) { // the current alignment is better; this can be accelerated in principle
+                    kh_put(name, del_set, strdup(bam_get_qname(p)), &ret); // p will be removed
+                    if (ret < 0) goto fail;
+                    if (bam_copy1(p, b) == NULL) goto fail; // replaced as b
+                } else kh_put(name, del_set, strdup(bam_get_qname(b)), &ret); // b will be removed
+                if (ret < 0) goto fail;
+                if (ret == 0)
+                    fprintf(samtools_stderr, "[bam_rmdup_core] inconsistent BAM file for pair '%s'. Continue anyway.\n", bam_get_qname(b));
+            } else { // not found in best_hash
+                kh_val(q->best_hash, k) = bam_dup1(b);
+                stack_insert(&stack, kh_val(q->best_hash, k));
+            }
+        } else { // paired, tail
+            k = kh_get(name, del_set, bam_get_qname(b));
+            if (k != kh_end(del_set)) {
+                free((char*)kh_key(del_set, k));
+                kh_del(name, del_set, k);
+            } else {
+                if (sam_write1(out, hdr, b) < 0) goto write_fail;
+            }
+        }
+        last_pos = c->pos;
+    }
+    if (r < -1) {
+        fprintf(samtools_stderr, "[%s] failed to read input file\n", __func__);
+        goto fail;
+    }
+
+    for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+        if (kh_exist(aux, k)) {
+            lib_aux_t *q = &kh_val(aux, k);
+            if (dump_best(&stack, out, hdr) < 0) goto write_fail;
+            fprintf(samtools_stderr, "[bam_rmdup_core] %lld / %lld = %.4lf in library '%s'\n", (long long)q->n_removed,
+                    (long long)q->n_checked, (double)q->n_removed/q->n_checked, kh_key(aux, k));
+            kh_destroy(pos, q->best_hash);
+            free((char*)kh_key(aux, k));
+            kh_del(lib, aux, k);
+        }
+    }
+    kh_destroy(lib, aux);
+
+    clear_del_set(del_set);
+    kh_destroy(name, del_set);
+    free(stack.a);
+    bam_destroy1(b);
+    return 0;
+
+ write_fail:
+    print_error_errno("rmdup", "failed to write record");
+ fail:
+    clear_stack(&stack);
+    free(stack.a);
+    if (aux) {
+        for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+            if (kh_exist(aux, k)) {
+                lib_aux_t *q = &kh_val(aux, k);
+                kh_destroy(pos, q->best_hash);
+                free((char*)kh_key(aux, k));
+            }
+        }
+        kh_destroy(lib, aux);
+    }
+    if (del_set) {
+        clear_del_set(del_set);
+        kh_destroy(name, del_set);
+    }
+    bam_destroy1(b);
+    return 1;
+}
+
+int bam_rmdupse_core(samFile *in, sam_hdr_t *hdr, samFile *out, int force_se);
+
+static int rmdup_usage(void) {
+    fprintf(samtools_stderr, "\n");
+    fprintf(samtools_stderr, "Usage:  samtools rmdup [-sS] <input.srt.bam> <output.bam>\n\n");
+    fprintf(samtools_stderr, "Option: -s    rmdup for SE reads\n");
+    fprintf(samtools_stderr, "        -S    treat PE reads as SE in rmdup (force -s)\n");
+
+    sam_global_opt_help(samtools_stderr, "-....--.");
+    return 1;
+}
+
+int bam_rmdup(int argc, char *argv[])
+{
+    int c, ret, is_se = 0, force_se = 0;
+    samFile *in, *out;
+    sam_hdr_t *header;
+    char wmode[3] = {'w', 'b', 0};
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 0, 0, 0, '-'),
+        { NULL, 0, NULL, 0 }
+    };
+
+    while ((c = getopt_long(argc, argv, "sS", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 's': is_se = 1; break;
+        case 'S': force_se = is_se = 1; break;
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?': return rmdup_usage();
+        }
+    }
+    if (optind + 2 > argc)
+        return rmdup_usage();
+
+    in = sam_open_format(argv[optind], "r", &ga.in);
+    if (!in) {
+        print_error_errno("rmdup", "failed to open \"%s\" for input", argv[optind]);
+        return 1;
+    }
+    header = sam_hdr_read(in);
+    if (header == NULL || sam_hdr_nref(header) == 0) {
+        fprintf(samtools_stderr, "[bam_rmdup] input SAM does not have header. Abort!\n");
+        return 1;
+    }
+
+    sam_open_mode(wmode+1, argv[optind+1], NULL);
+    out = sam_open_format(argv[optind+1], wmode, &ga.out);
+    if (!out) {
+        print_error_errno("rmdup", "failed to open \"%s\" for output", argv[optind+1]);
+        return 1;
+    }
+    if (sam_hdr_write(out, header) < 0) {
+        print_error_errno("rmdup", "failed to write header");
+        return 1;
+    }
+
+    if (is_se) ret = bam_rmdupse_core(in, header, out, force_se);
+    else ret = bam_rmdup_core(in, header, out);
+
+    sam_hdr_destroy(header);
+    sam_close(in);
+    if (sam_close(out) < 0) {
+        fprintf(samtools_stderr, "[bam_rmdup] error closing output file\n");
+        ret = 1;
+    }
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_rmdupse.c

@@ -0,0 +1,230 @@
+/*  bam_rmdupse.c -- duplicate read detection for unpaired reads.
+
+    Copyright (C) 2009, 2015, 2016, 2019 Genome Research Ltd.
+    Portions copyright (C) 2009 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <math.h>
+#include <stdio.h>
+#include "bam.h" // for bam_get_library
+#include "htslib/sam.h"
+#include "htslib/khash.h"
+#include "htslib/klist.h"
+#include "samtools.h"
+
+#define QUEUE_CLEAR_SIZE 0x100000
+#define MAX_POS 0x7fffffff
+
+typedef struct {
+    int endpos;
+    uint32_t score:31, discarded:1;
+    bam1_t *b;
+} elem_t, *elem_p;
+#define __free_elem(p) bam_destroy1((p)->data.b)
+KLIST_INIT(q, elem_t, __free_elem)
+typedef klist_t(q) queue_t;
+
+KHASH_MAP_INIT_INT(best, elem_p)
+typedef khash_t(best) besthash_t;
+
+typedef struct {
+    uint64_t n_checked, n_removed;
+    besthash_t *left, *rght;
+} lib_aux_t;
+KHASH_MAP_INIT_STR(lib, lib_aux_t)
+
+static lib_aux_t *get_aux(khash_t(lib) *aux, const char *lib)
+{
+    khint_t k = kh_get(lib, aux, lib);
+    if (k == kh_end(aux)) {
+        int ret;
+        char *p = strdup(lib);
+        lib_aux_t *q;
+        k = kh_put(lib, aux, p, &ret);
+        q = &kh_val(aux, k);
+        q->left = kh_init(best);
+        q->rght = kh_init(best);
+        q->n_checked = q->n_removed = 0;
+        return q;
+    } else return &kh_val(aux, k);
+}
+
+static inline int sum_qual(const bam1_t *b)
+{
+    int i, q;
+    uint8_t *qual = bam_get_qual(b);
+    for (i = q = 0; i < b->core.l_qseq; ++i) q += qual[i];
+    return q;
+}
+
+static inline elem_t *push_queue(queue_t *queue, const bam1_t *b, int endpos, int score)
+{
+    elem_t *p = kl_pushp(q, queue);
+    p->discarded = 0;
+    p->endpos = endpos; p->score = score;
+    if (p->b == 0) p->b = bam_init1();
+    if (!p->b) { perror(NULL); exit(EXIT_FAILURE); }
+    if (bam_copy1(p->b, b) == NULL) { perror(NULL); exit(EXIT_FAILURE); }
+    return p;
+}
+
+static void clear_besthash(besthash_t *h, int32_t pos)
+{
+    khint_t k;
+    for (k = kh_begin(h); k != kh_end(h); ++k)
+        if (kh_exist(h, k) && kh_val(h, k)->endpos <= pos)
+            kh_del(best, h, k);
+}
+
+static int dump_alignment(samFile *out, sam_hdr_t *hdr,
+                          queue_t *queue, int32_t pos, khash_t(lib) *h)
+{
+    if (queue->size > QUEUE_CLEAR_SIZE || pos == MAX_POS) {
+        khint_t k;
+        while (1) {
+            elem_t *q;
+            if (queue->head == queue->tail) break;
+            q = &kl_val(queue->head);
+            if (q->discarded) {
+                q->b->l_data = 0;
+                kl_shift(q, queue, 0);
+                continue;
+            }
+            if ((q->b->core.flag&BAM_FREVERSE) && q->endpos > pos) break;
+            if (sam_write1(out, hdr, q->b) < 0) return -1;
+            q->b->l_data = 0;
+            kl_shift(q, queue, 0);
+        }
+        for (k = kh_begin(h); k != kh_end(h); ++k) {
+            if (kh_exist(h, k)) {
+                clear_besthash(kh_val(h, k).left, pos);
+                clear_besthash(kh_val(h, k).rght, pos);
+            }
+        }
+    }
+    return 0;
+}
+
+int bam_rmdupse_core(samFile *in, sam_hdr_t *hdr, samFile *out, int force_se)
+{
+    bam1_t *b = NULL;
+    queue_t *queue = NULL;
+    khint_t k;
+    int last_tid = -2, r;
+    khash_t(lib) *aux = NULL;
+
+    aux = kh_init(lib);
+    b = bam_init1();
+    queue = kl_init(q);
+    if (!aux || !b || !queue) {
+        perror(__func__);
+        goto fail;
+    }
+
+    while ((r = sam_read1(in, hdr, b)) >= 0) {
+        bam1_core_t *c = &b->core;
+        int endpos = bam_endpos(b);
+        int score = sum_qual(b);
+
+        if (last_tid != c->tid) {
+            if (last_tid >= 0) {
+                if (dump_alignment(out, hdr, queue, MAX_POS, aux) < 0)
+                    goto write_fail;
+            }
+            last_tid = c->tid;
+        } else {
+            if (dump_alignment(out, hdr, queue, c->pos, aux) < 0)
+                goto write_fail;
+        }
+        if ((c->flag&BAM_FUNMAP) || ((c->flag&BAM_FPAIRED) && !force_se)) {
+            push_queue(queue, b, endpos, score);
+        } else {
+            const char *lib;
+            lib_aux_t *q;
+            besthash_t *h;
+            uint32_t key;
+            int ret;
+            lib = bam_get_library(hdr, b);
+            q = lib? get_aux(aux, lib) : get_aux(aux, "\t");
+            ++q->n_checked;
+            h = (c->flag&BAM_FREVERSE)? q->rght : q->left;
+            key = (c->flag&BAM_FREVERSE)? endpos : c->pos;
+            k = kh_put(best, h, key, &ret);
+            if (ret == 0) { // in the hash table
+                elem_t *p = kh_val(h, k);
+                ++q->n_removed;
+                if (p->score < score) {
+                    if (c->flag&BAM_FREVERSE) { // mark "discarded" and push the queue
+                        p->discarded = 1;
+                        kh_val(h, k) = push_queue(queue, b, endpos, score);
+                    } else { // replace
+                        p->score = score; p->endpos = endpos;
+                        if (bam_copy1(p->b, b) == NULL) {
+                            perror(NULL); exit(EXIT_FAILURE);
+                        }
+                    }
+                } // otherwise, discard the alignment
+            } else kh_val(h, k) = push_queue(queue, b, endpos, score);
+        }
+    }
+    if (r < -1) {
+        fprintf(stderr, "[%s] error reading input file\n", __func__);
+        goto fail;
+    }
+
+    if (dump_alignment(out, hdr, queue, MAX_POS, aux) < 0) goto write_fail;
+
+    for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+        if (kh_exist(aux, k)) {
+            lib_aux_t *q = &kh_val(aux, k);
+            fprintf(stderr, "[bam_rmdupse_core] %lld / %lld = %.4lf in library '%s'\n", (long long)q->n_removed,
+                    (long long)q->n_checked, (double)q->n_removed/q->n_checked, kh_key(aux, k));
+            kh_destroy(best, q->left); kh_destroy(best, q->rght);
+            free((char*)kh_key(aux, k));
+            kh_del(lib, aux, k);
+        }
+    }
+    kh_destroy(lib, aux);
+    bam_destroy1(b);
+    kl_destroy(q, queue);
+    return 0;
+
+ write_fail:
+    print_error_errno("rmdup", "failed to write record");
+ fail:
+    if (aux) {
+        for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+            if (kh_exist(aux, k)) {
+                lib_aux_t *q = &kh_val(aux, k);
+                kh_destroy(best, q->left);
+                kh_destroy(best, q->rght);
+                free((char*)kh_key(aux, k));
+            }
+        }
+        kh_destroy(lib, aux);
+    }
+    bam_destroy1(b);
+    kl_destroy(q, queue);
+    return 1;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_rmdupse.c.pysam.c

@@ -0,0 +1,232 @@
+#include "samtools.pysam.h"
+
+/*  bam_rmdupse.c -- duplicate read detection for unpaired reads.
+
+    Copyright (C) 2009, 2015, 2016, 2019 Genome Research Ltd.
+    Portions copyright (C) 2009 Broad Institute.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <math.h>
+#include <stdio.h>
+#include "bam.h" // for bam_get_library
+#include "htslib/sam.h"
+#include "htslib/khash.h"
+#include "htslib/klist.h"
+#include "samtools.h"
+
+#define QUEUE_CLEAR_SIZE 0x100000
+#define MAX_POS 0x7fffffff
+
+typedef struct {
+    int endpos;
+    uint32_t score:31, discarded:1;
+    bam1_t *b;
+} elem_t, *elem_p;
+#define __free_elem(p) bam_destroy1((p)->data.b)
+KLIST_INIT(q, elem_t, __free_elem)
+typedef klist_t(q) queue_t;
+
+KHASH_MAP_INIT_INT(best, elem_p)
+typedef khash_t(best) besthash_t;
+
+typedef struct {
+    uint64_t n_checked, n_removed;
+    besthash_t *left, *rght;
+} lib_aux_t;
+KHASH_MAP_INIT_STR(lib, lib_aux_t)
+
+static lib_aux_t *get_aux(khash_t(lib) *aux, const char *lib)
+{
+    khint_t k = kh_get(lib, aux, lib);
+    if (k == kh_end(aux)) {
+        int ret;
+        char *p = strdup(lib);
+        lib_aux_t *q;
+        k = kh_put(lib, aux, p, &ret);
+        q = &kh_val(aux, k);
+        q->left = kh_init(best);
+        q->rght = kh_init(best);
+        q->n_checked = q->n_removed = 0;
+        return q;
+    } else return &kh_val(aux, k);
+}
+
+static inline int sum_qual(const bam1_t *b)
+{
+    int i, q;
+    uint8_t *qual = bam_get_qual(b);
+    for (i = q = 0; i < b->core.l_qseq; ++i) q += qual[i];
+    return q;
+}
+
+static inline elem_t *push_queue(queue_t *queue, const bam1_t *b, int endpos, int score)
+{
+    elem_t *p = kl_pushp(q, queue);
+    p->discarded = 0;
+    p->endpos = endpos; p->score = score;
+    if (p->b == 0) p->b = bam_init1();
+    if (!p->b) { perror(NULL); samtools_exit(EXIT_FAILURE); }
+    if (bam_copy1(p->b, b) == NULL) { perror(NULL); samtools_exit(EXIT_FAILURE); }
+    return p;
+}
+
+static void clear_besthash(besthash_t *h, int32_t pos)
+{
+    khint_t k;
+    for (k = kh_begin(h); k != kh_end(h); ++k)
+        if (kh_exist(h, k) && kh_val(h, k)->endpos <= pos)
+            kh_del(best, h, k);
+}
+
+static int dump_alignment(samFile *out, sam_hdr_t *hdr,
+                          queue_t *queue, int32_t pos, khash_t(lib) *h)
+{
+    if (queue->size > QUEUE_CLEAR_SIZE || pos == MAX_POS) {
+        khint_t k;
+        while (1) {
+            elem_t *q;
+            if (queue->head == queue->tail) break;
+            q = &kl_val(queue->head);
+            if (q->discarded) {
+                q->b->l_data = 0;
+                kl_shift(q, queue, 0);
+                continue;
+            }
+            if ((q->b->core.flag&BAM_FREVERSE) && q->endpos > pos) break;
+            if (sam_write1(out, hdr, q->b) < 0) return -1;
+            q->b->l_data = 0;
+            kl_shift(q, queue, 0);
+        }
+        for (k = kh_begin(h); k != kh_end(h); ++k) {
+            if (kh_exist(h, k)) {
+                clear_besthash(kh_val(h, k).left, pos);
+                clear_besthash(kh_val(h, k).rght, pos);
+            }
+        }
+    }
+    return 0;
+}
+
+int bam_rmdupse_core(samFile *in, sam_hdr_t *hdr, samFile *out, int force_se)
+{
+    bam1_t *b = NULL;
+    queue_t *queue = NULL;
+    khint_t k;
+    int last_tid = -2, r;
+    khash_t(lib) *aux = NULL;
+
+    aux = kh_init(lib);
+    b = bam_init1();
+    queue = kl_init(q);
+    if (!aux || !b || !queue) {
+        perror(__func__);
+        goto fail;
+    }
+
+    while ((r = sam_read1(in, hdr, b)) >= 0) {
+        bam1_core_t *c = &b->core;
+        int endpos = bam_endpos(b);
+        int score = sum_qual(b);
+
+        if (last_tid != c->tid) {
+            if (last_tid >= 0) {
+                if (dump_alignment(out, hdr, queue, MAX_POS, aux) < 0)
+                    goto write_fail;
+            }
+            last_tid = c->tid;
+        } else {
+            if (dump_alignment(out, hdr, queue, c->pos, aux) < 0)
+                goto write_fail;
+        }
+        if ((c->flag&BAM_FUNMAP) || ((c->flag&BAM_FPAIRED) && !force_se)) {
+            push_queue(queue, b, endpos, score);
+        } else {
+            const char *lib;
+            lib_aux_t *q;
+            besthash_t *h;
+            uint32_t key;
+            int ret;
+            lib = bam_get_library(hdr, b);
+            q = lib? get_aux(aux, lib) : get_aux(aux, "\t");
+            ++q->n_checked;
+            h = (c->flag&BAM_FREVERSE)? q->rght : q->left;
+            key = (c->flag&BAM_FREVERSE)? endpos : c->pos;
+            k = kh_put(best, h, key, &ret);
+            if (ret == 0) { // in the hash table
+                elem_t *p = kh_val(h, k);
+                ++q->n_removed;
+                if (p->score < score) {
+                    if (c->flag&BAM_FREVERSE) { // mark "discarded" and push the queue
+                        p->discarded = 1;
+                        kh_val(h, k) = push_queue(queue, b, endpos, score);
+                    } else { // replace
+                        p->score = score; p->endpos = endpos;
+                        if (bam_copy1(p->b, b) == NULL) {
+                            perror(NULL); samtools_exit(EXIT_FAILURE);
+                        }
+                    }
+                } // otherwise, discard the alignment
+            } else kh_val(h, k) = push_queue(queue, b, endpos, score);
+        }
+    }
+    if (r < -1) {
+        fprintf(samtools_stderr, "[%s] error reading input file\n", __func__);
+        goto fail;
+    }
+
+    if (dump_alignment(out, hdr, queue, MAX_POS, aux) < 0) goto write_fail;
+
+    for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+        if (kh_exist(aux, k)) {
+            lib_aux_t *q = &kh_val(aux, k);
+            fprintf(samtools_stderr, "[bam_rmdupse_core] %lld / %lld = %.4lf in library '%s'\n", (long long)q->n_removed,
+                    (long long)q->n_checked, (double)q->n_removed/q->n_checked, kh_key(aux, k));
+            kh_destroy(best, q->left); kh_destroy(best, q->rght);
+            free((char*)kh_key(aux, k));
+            kh_del(lib, aux, k);
+        }
+    }
+    kh_destroy(lib, aux);
+    bam_destroy1(b);
+    kl_destroy(q, queue);
+    return 0;
+
+ write_fail:
+    print_error_errno("rmdup", "failed to write record");
+ fail:
+    if (aux) {
+        for (k = kh_begin(aux); k != kh_end(aux); ++k) {
+            if (kh_exist(aux, k)) {
+                lib_aux_t *q = &kh_val(aux, k);
+                kh_destroy(best, q->left);
+                kh_destroy(best, q->rght);
+                free((char*)kh_key(aux, k));
+            }
+        }
+        kh_destroy(lib, aux);
+    }
+    bam_destroy1(b);
+    kl_destroy(q, queue);
+    return 1;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_samples.c

@@ -0,0 +1,433 @@
+/*  bam_samples -- print samples in a set of BAM files
+
+    Copyright (C) 2021 Pierre Lindenbaum
+    Institut du Thorax. u1087 Nantes. France.
+    @yokofakun
+
+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.  */
+
+#include <config.h>
+#include <htslib/hts.h>
+#include <htslib/sam.h>
+#include <htslib/faidx.h>
+#include <htslib/khash.h>
+#include <htslib/kseq.h>
+#include <samtools.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+
+KHASH_MAP_INIT_STR(sm, int)
+
+/** and chained struct containing the faidx and the fasta filename
+    will be compared with the @SQ lines in the SAM header
+ */
+typedef struct FaidxPath {
+    /** path to reference */
+    char* filename;
+    /** fasta index  */
+    faidx_t* faidx;
+    struct FaidxPath* next;
+} FaidxPath;
+
+/** program parameters */
+typedef struct Params {
+    /** output stream */
+    FILE* out;
+    /** tag in @RG line. default is "SM" */
+    char tag[3];
+    /** first faidx/path in chained list */
+    FaidxPath* faidx;
+    /** show whether the bam is indexed */
+    int test_index;
+} Params;
+
+/** print usage */
+static void usage_samples(FILE *write_to) {
+    fprintf(write_to,
+            "Usage: samtools samples [options] <input> [...]\n"
+            "       samtools samples [options] -X f1.bam f2.bam f1.bam.bai f2.bai \n"
+            "       find dir1 dir2 -type f \\(-name \"*.bam\" -o -name \"*.cram\" \\) | samtools samples [options]\n"
+            "       find dir1 dir2 -type f \\(-name \"*.bam\" -o -name \"*.bai\" \\) | sort | paste - - | samtools samples -X [options]\n"
+            "\n"
+            "Options:\n"
+            "  -?              print help and exit\n"
+            "  -h              add the columns header before printing the results\n"
+            "  -i              test if the file is indexed.\n"
+            "  -T <tag>        provide the sample tag name from the @RG line [SM].\n"
+            "  -o <file>       output file [stdout].\n"
+            "  -f <file.fa>    load an indexed fasta file in the collection of references. Can be used multiple times.\n"
+            "  -F <file.txt>   read a file containing the paths to indexed fasta files. One path per line.\n"
+            "  -X              use a custom index file.\n"
+            "\n"
+            " Using -f or -F will add a column containing the path to the reference or \".\" if the reference was not found.\n"
+            "\n"
+    );
+}
+
+
+/** loads fasta fai file into FaidxPath, add it to params->faidx */
+static int load_dictionary(struct Params* params, const char* filename) {
+    FaidxPath* head = params->faidx;
+    FaidxPath* ptr = (FaidxPath*)malloc(sizeof(FaidxPath));
+    if (ptr == NULL) {
+        print_error_errno("samples", "Out of memory");
+        return EXIT_FAILURE;
+    }
+    ptr->filename = strdup(filename);
+    if (ptr->filename == NULL) {
+        free(ptr);
+        print_error_errno("samples", "Out of memory");
+        return EXIT_FAILURE;
+    }
+    ptr->faidx = fai_load(filename);
+    if (ptr->faidx == NULL) {
+        free(ptr->filename);
+        free(ptr);
+        print_error_errno("samples", "Cannot load index from \"%s\"", filename);
+        return EXIT_FAILURE;
+    }
+    /* insert at the beginning of the linked list */
+    params->faidx = ptr;
+    ptr->next = head;
+    return EXIT_SUCCESS;
+}
+
+/** load a faidx file and append it to params */
+static int load_dictionaries(Params* params, const char* filename) {
+    int ret;
+    htsFile* in;
+    int status = EXIT_SUCCESS;
+
+    in = hts_open(filename, "r");
+    if (in == NULL) {
+        print_error_errno("samples", "Cannot open \"%s\"", filename);
+        status = EXIT_FAILURE;
+    } else {
+        kstring_t ks = KS_INITIALIZE;
+        while ((ret = hts_getline(in, KS_SEP_LINE, &ks)) >= 0) {
+            if (load_dictionary(params, ks_str(&ks)) != EXIT_SUCCESS) {
+                status = EXIT_FAILURE;
+                break;
+            }
+        }
+        ks_free(&ks);
+        hts_close(in);
+    }
+    return status;
+}
+
+/** print the sample information, search for a reference */
+static int print_sample(
+        Params* params,
+        sam_hdr_t *header,
+        int has_index,
+        const char* sample,
+        const char* fname) {
+    fputs(sample, params->out);
+    fputc('\t', params->out);
+    fputs(fname, params->out);
+    if (params->test_index) {
+        fprintf(params->out, "\t%c", has_index ? 'Y' : 'N');
+    }
+    if (params->faidx != NULL) {
+        FaidxPath* ref = NULL;
+        FaidxPath* curr = params->faidx;
+        while (curr != NULL) {
+            /** check names and length are the same in the same order */
+            if (faidx_nseq(curr->faidx) == header->n_targets) {
+                int i;
+                for (i = 0; i < faidx_nseq(curr->faidx); i++) {
+                    /** check name is the same */
+                    if (strcmp(faidx_iseq(curr->faidx, i), header->target_name[i]) != 0) break;
+                    /** check length is the same */
+                    if (faidx_seq_len(curr->faidx, faidx_iseq(curr->faidx, i)) != header->target_len[i]) break;
+                }
+                /* the ref was found */
+                if (i == faidx_nseq(curr->faidx)) {
+                    ref = curr;
+                    break;
+                }
+            }
+            curr = curr->next;
+        }
+        fputc('\t', params->out);
+        if (ref == NULL) {
+            fputc('.', params->out);
+        } else {
+            fputs(curr->filename, params->out);
+        }
+    }
+    fputc('\n', params->out);
+    return 0;
+}
+
+/** open a sam file. Search for all samples in the @RG lines */
+static int print_samples(Params* params, const char* fname, const char* baifname) {
+    samFile *in = 0;
+    sam_hdr_t *header = NULL;
+    int n_rg;
+    int status = EXIT_SUCCESS;
+    khash_t(sm) *sample_set = NULL;
+    khint_t k;
+    int count_samples = 0;
+    int has_index = 0;
+
+    if ((sample_set = kh_init(sm)) == NULL) {
+        print_error("samples", "Failed to initialise sample hash");
+        status = EXIT_FAILURE;
+        goto end_print;
+    }
+
+    if ((in = sam_open_format(fname, "r", NULL)) == 0) {
+        print_error_errno("samples", "Failed to open \"%s\" for reading", fname);
+        status = EXIT_FAILURE;
+        goto end_print;
+    }
+    if ((header = sam_hdr_read(in)) == 0) {
+        print_error("samples", "Failed to read the header from \"%s\"", fname);
+        status = EXIT_FAILURE;
+        goto end_print;
+    }
+
+    /* try to load index if required */
+    if (params->test_index) {
+        hts_idx_t *bam_idx;
+        /* path to bam index was specified */
+        if (baifname != NULL) {
+            bam_idx = sam_index_load3(in, fname, baifname, HTS_IDX_SILENT_FAIL);
+        }
+        /* get default index */
+        else {
+            bam_idx = sam_index_load3(in, fname, NULL, HTS_IDX_SILENT_FAIL);
+        }
+        has_index = bam_idx != NULL;
+        if (bam_idx != NULL) hts_idx_destroy(bam_idx);
+        /* and we continue... we have tested the index file but we always test for the samples and the references */
+    }
+
+    /* get the RG lines */
+    n_rg = sam_hdr_count_lines(header, "RG");
+    if (n_rg > 0) {
+        int i, r, ret;
+        char* sample;
+        kstring_t sm_val = KS_INITIALIZE;
+        for (i = 0; i < n_rg; i++) {
+            r = sam_hdr_find_tag_pos(header, "RG", i, params->tag, &sm_val);
+            if (r < 0) continue;
+            k = kh_get(sm, sample_set, ks_str(&sm_val));
+            if (k != kh_end(sample_set)) continue;
+            sample = strdup(ks_str(&sm_val));
+            if (sample == NULL) {
+                print_error_errno("samples", "Out of memory");
+                status = EXIT_FAILURE;
+                goto end_print;
+            }
+            kh_put(sm, sample_set, sample, &ret);
+            if (ret < 0) {
+                print_error("samples", "Failed to insert key '%s' into sample_set", sample);
+                free(sample);
+                status = EXIT_FAILURE;
+                goto end_print;
+            }
+            ++count_samples;
+        }
+        ks_free(&sm_val);
+    }
+    if (count_samples == 0) {
+        print_sample(params, header, has_index, ".", fname);
+    } else {
+        for (k = kh_begin(sample_set); k != kh_end(sample_set); ++k) {
+            if (kh_exist(sample_set, k)) {
+                char* sample = (char*)kh_key(sample_set, k);
+                print_sample(params, header, has_index, sample, fname);
+            }
+        }
+    }
+
+end_print:
+    if (sample_set != NULL) {
+        for (k = kh_begin(sample_set); k != kh_end(sample_set); ++k) {
+            if (kh_exist(sample_set, k)) {
+                char* sample = (char*)kh_key(sample_set, k);
+                free(sample);
+            }
+        }
+        kh_destroy(sm, sample_set);
+    }
+    if (header != NULL) sam_hdr_destroy(header);
+    if (in != NULL) sam_close(in);
+
+    return status;
+}
+
+
+int main_samples(int argc, char** argv) {
+    int status = EXIT_SUCCESS;
+    int print_header = 0;
+    int has_index_file = 0;
+    Params params;
+    char* out_filename = NULL;
+    FaidxPath* fai;
+
+    strcpy(params.tag, "SM");
+    params.faidx = NULL;
+    params.test_index =0;
+
+    int opt;
+    while ((opt = getopt_long(argc, argv,  "?hiXo:f:F:T:", NULL, NULL)) != -1) {
+        switch (opt) {
+        case 'h':
+            print_header = 1;
+            break;
+        case 'o':
+            out_filename = optarg;
+            break;
+        case 'i':
+            params.test_index = 1;
+            break;
+        case 'f':
+            if (load_dictionary(&params, optarg) != EXIT_SUCCESS) {
+                return EXIT_FAILURE;
+            }
+            break;
+        case 'F':
+            if (load_dictionaries(&params, optarg) != EXIT_SUCCESS) {
+                return EXIT_FAILURE;
+            }
+            break;
+        case 'T':
+            if (strlen(optarg) != 2) {
+                print_error("samples", "Length of tag \"%s\" is not 2.", optarg);
+                return EXIT_FAILURE;
+            }
+            strcpy(params.tag, optarg);
+            break;
+        case '?':
+            usage_samples(stdout);
+            return EXIT_SUCCESS;
+        case 'X':
+            has_index_file = 1;
+            break;
+        default:
+            usage_samples(stderr);
+            return EXIT_FAILURE;
+        }
+    }
+
+    /* if no file was provided and input is the terminal, print the usage and exit */
+    if (argc == optind && isatty(STDIN_FILENO)) {
+       usage_samples(stderr);
+       return EXIT_FAILURE;
+    }
+
+    if (out_filename != NULL) {
+        params.out = fopen(out_filename, "w");
+        if (params.out == NULL) {
+            print_error_errno("samples", "Cannot open \"%s\" for writing", out_filename);
+            return EXIT_FAILURE;
+        }
+    } else {
+        params.out = stdout;
+    }
+
+    if (print_header) {
+        fprintf(params.out, "#%s\tPATH", params.tag);
+        if (params.test_index) fprintf(params.out, "\tINDEX");
+        if (params.faidx != NULL) fprintf(params.out, "\tREFERENCE");
+        fprintf(params.out, "\n");
+    }
+
+    /* no file was provided, input is stdin, each line contains the path to a bam file */
+    if (argc == optind) {
+        htsFile* fp = hts_open("-", "r");
+        if (fp == NULL) {
+            print_error_errno("samples", "Cannot read from stdin");
+            status = EXIT_FAILURE;
+        } else {
+            kstring_t ks = KS_INITIALIZE;
+            int ret;
+            while ((ret = hts_getline(fp, KS_SEP_LINE, &ks)) >= 0) {
+                char* bai_path = NULL;
+                if (has_index_file) {
+                    /* bam path and bam index file are separated by a tab */
+                    char* tab = strchr(ks_str(&ks), '\t');
+                    if (tab == NULL || *(tab+1) == '\0') {
+                        print_error_errno("samples", "Expected path-to-bam(tab)path-to-index but got \"%s\"", ks_str(&ks));
+                        status = EXIT_FAILURE;
+                        break;
+                    }
+                    *tab=0;
+                    bai_path = (tab + 1);
+                }
+                if (print_samples(&params, ks_str(&ks), bai_path) != EXIT_SUCCESS) {
+                    status = EXIT_FAILURE;
+                    break;
+                }
+            }
+            ks_free(&ks);
+            hts_close(fp);
+        }
+    }
+    /* loop over each file in argc/argv bam index provided */
+    else if (has_index_file) {
+        /* calculate number of input BAM files */
+        if ((argc - optind) % 2 != 0) {
+            print_error("samples","Odd number of filenames detected! Each BAM file should have an index file");
+            status = EXIT_FAILURE;
+        } else {
+            int i;
+            int n = (argc - optind ) / 2;
+            for (i = 0; i < n; i++) {
+                if (print_samples(&params, argv[optind+i], argv[optind+i+n]) != EXIT_SUCCESS) {
+                    status = EXIT_FAILURE;
+                    break;
+                }
+            }
+        }
+    } else {
+        int i;
+        for (i = optind; i < argc; i++) {
+            if (print_samples(&params, argv[i], NULL) != EXIT_SUCCESS) {
+                status = EXIT_FAILURE;
+                break;
+            }
+        }
+    }
+
+    fai = params.faidx;
+    while (fai != NULL) {
+        FaidxPath* next = fai -> next;
+        free(fai->filename);
+        fai_destroy(fai->faidx);
+        free(fai);
+        fai = next;
+    }
+
+    if (fflush(params.out) != 0) {
+        print_error_errno("samples", "Cannot flush output");
+        status = EXIT_FAILURE;
+    }
+    if (out_filename != NULL) {
+        fclose(params.out);
+    }
+
+    return status;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_split.c

@@ -0,0 +1,618 @@
+/*  bam_split.c -- split subcommand.
+
+    Copyright (C) 2013-2016,2018-2019,2023 Genome Research Ltd.
+
+    Author: Martin Pollard <mp15@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <unistd.h>
+#include <regex.h>
+#include <assert.h>
+#include <htslib/sam.h>
+#include <htslib/khash.h>
+#include <htslib/kstring.h>
+#include <htslib/cram.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include "samtools.h"
+
+
+KHASH_MAP_INIT_STR(c2i, int)
+
+struct parsed_opts {
+    const char *merged_input_name;
+    const char *unaccounted_header_name;
+    const char *unaccounted_name;
+    const char *output_format_string;
+    bool verbose;
+    int no_pg;
+    sam_global_args ga;
+};
+
+typedef struct parsed_opts parsed_opts_t;
+
+struct state {
+    samFile* merged_input_file;
+    sam_hdr_t* merged_input_header;
+    samFile* unaccounted_file;
+    sam_hdr_t* unaccounted_header;
+    size_t output_count;
+    char** rg_id;
+    char **rg_index_file_name;
+    char **rg_output_file_name;
+    samFile** rg_output_file;
+    sam_hdr_t** rg_output_header;
+    kh_c2i_t* rg_hash;
+    htsThreadPool p;
+    int write_index;
+};
+
+typedef struct state state_t;
+
+static int cleanup_state(state_t* status, bool check_close);
+static void cleanup_opts(parsed_opts_t* opts);
+
+static void usage(FILE *write_to)
+{
+    fprintf(write_to,
+"Usage: samtools split [-u <unaccounted.bam>] [-h <unaccounted_header.sam>]\n"
+"                      [-f <format_string>] [-v] <merged.bam>\n"
+"Options:\n"
+"  -f STRING       output filename format string [\"%%*_%%#.%%.\"]\n"
+"  -u FILE1        put reads with no RG tag or an unrecognised RG tag in FILE1\n"
+"  -h FILE2        ... and override the header with FILE2 (-u file only)\n"
+"  -v              verbose output\n"
+"  --no-PG         do not add a PG line\n");
+    sam_global_opt_help(write_to, "-....@..");
+    fprintf(write_to,
+"\n"
+"Format string expansions:\n"
+"  %%%%     %%\n"
+"  %%*     basename\n"
+"  %%#     @RG index\n"
+"  %%!     @RG ID\n"
+"  %%.     filename extension for output format\n"
+      );
+}
+
+// Takes the command line options and turns them into something we can understand
+static parsed_opts_t* parse_args(int argc, char** argv)
+{
+    if (argc == 1) { usage(stdout); return NULL; }
+
+    const char *optstring = "vf:h:u:@:";
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 0, 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+
+    parsed_opts_t* retval = calloc(sizeof(parsed_opts_t), 1);
+    if (! retval ) { perror("cannot allocate option parsing memory"); return NULL; }
+
+    sam_global_args_init(&retval->ga);
+
+    int opt;
+    while ((opt = getopt_long(argc, argv, optstring, lopts, NULL)) != -1) {
+        switch (opt) {
+        case 'f':
+            retval->output_format_string = optarg;
+            break;
+        case 'h':
+            retval->unaccounted_header_name = optarg;
+            break;
+        case 'v':
+            retval->verbose = true;
+            break;
+        case 'u':
+            retval->unaccounted_name = optarg;
+            break;
+        case 1:
+            retval->no_pg = 1;
+            break;
+        default:
+            if (parse_sam_global_opt(opt, optarg, lopts, &retval->ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage(stdout);
+            free(retval);
+            return NULL;
+        }
+    }
+
+    if (retval->output_format_string == NULL) retval->output_format_string = "%*_%#.%.";
+
+    argc -= optind;
+    argv += optind;
+
+    if (argc != 1) {
+        print_error("split", "Invalid number of arguments: %d", argc);
+        usage(stderr);
+        free(retval);
+        return NULL;
+    }
+
+    retval->merged_input_name = argv[0];
+
+    return retval;
+}
+
+// Expands a output filename format string
+static char* expand_format_string(const char* format_string, const char* basename, const char* rg_id, const int rg_idx, const htsFormat *format)
+{
+    kstring_t str = { 0, 0, NULL };
+    const char* pointer = format_string;
+    const char* next;
+    while ((next = strchr(pointer, '%')) != NULL) {
+        if (kputsn(pointer, next-pointer, &str) < 0) goto memfail;
+        ++next;
+        switch (*next) {
+            case '%':
+                if (kputc('%', &str) < 0) goto memfail;
+                break;
+            case '*':
+                if (kputs(basename, &str) < 0) goto memfail;
+                break;
+            case '#':
+                if (kputl(rg_idx, &str) < 0) goto memfail;
+                break;
+            case '!':
+                if (kputs(rg_id, &str) < 0) goto memfail;
+                break;
+            case '.':
+                // Only really need to cope with sam, bam, cram
+                if (format->format != unknown_format) {
+                    if (kputs(hts_format_file_extension(format), &str) < 0)
+                        goto memfail;
+                } else {
+                    if (kputs("bam", &str) < 0) goto memfail;
+                }
+                break;
+            case '\0':
+                print_error("split", "Trailing %% in filename format string");
+                goto fail;
+            default:
+                // Error is: fprintf(stderr, "bad format string, unknown format specifier\n");
+                print_error("split", "Unknown specifier %%%c in filename format string", *next);
+                goto fail;
+        }
+        pointer = next + 1;
+    }
+    if (kputs(pointer, &str) < 0) goto memfail;
+    return ks_release(&str);
+
+ memfail:
+    print_error_errno("split", "Couldn't build output filename");
+ fail:
+    free(str.s);
+    return NULL;
+}
+
+// Parse the header, count the number of RG tags and return a list of their names
+static bool count_RG(sam_hdr_t* hdr, size_t* count, char*** output_name)
+{
+    char **names = NULL;
+    kstring_t id_val = KS_INITIALIZE;
+    int i, n_rg = sam_hdr_count_lines(hdr, "RG");
+
+    if (n_rg < 0) {
+        print_error("split", "Failed to get @RG IDs");
+        *count = 0;
+        *output_name = NULL;
+        return false;
+    }
+
+    if (n_rg == 0) {
+        *count = 0;
+        *output_name = NULL;
+        return true;
+    }
+
+    names = calloc(n_rg, sizeof(names[0]));
+    if (!names) goto memfail;
+
+    for (i = 0; i < n_rg; i++) {
+        if (sam_hdr_find_tag_pos(hdr, "RG", i, "ID", &id_val) < 0) goto memfail;
+        names[i] = ks_release(&id_val);
+    }
+
+    *count = n_rg;
+    *output_name = names;
+    return true;
+
+ memfail:
+    print_error_errno("split", "Failed to get @RG IDs");
+    *count = 0;
+    *output_name = NULL;
+    ks_free(&id_val);
+    free(names);
+    return false;
+}
+
+static int header_compatible(sam_hdr_t *hdr1, sam_hdr_t *hdr2)
+{
+    size_t n;
+    if (sam_hdr_nref(hdr1) != sam_hdr_nref(hdr2)) {
+        print_error("split",
+                    "Unaccounted header contains wrong number of references");
+        return -1;
+    }
+    for (n = 0; n < sam_hdr_nref(hdr1); n++) {
+        hts_pos_t h1_len = sam_hdr_tid2len(hdr1, n);
+        hts_pos_t h2_len = sam_hdr_tid2len(hdr2, n);
+        if (h1_len != h2_len) {
+            print_error("split",
+                        "Unaccounted header reference %zu \"%s\" is not the same length as in the input file",
+                        n + 1, sam_hdr_tid2name(hdr2, n));
+            return -1;
+        }
+    }
+    return 0;
+}
+
+// Set the initial state
+static state_t* init(parsed_opts_t* opts, const char *arg_list)
+{
+    state_t* retval = calloc(sizeof(state_t), 1);
+    if (!retval) {
+        print_error_errno("split", "Initialisation failed");
+        return NULL;
+    }
+
+    if (opts->ga.nthreads > 0) {
+        if (!(retval->p.pool = hts_tpool_init(opts->ga.nthreads))) {
+            fprintf(stderr, "Error creating thread pool\n");
+            cleanup_state(retval, false);
+            return NULL;
+        }
+    }
+
+    retval->merged_input_file = sam_open_format(opts->merged_input_name, "r", &opts->ga.in);
+    if (!retval->merged_input_file) {
+        print_error_errno("split", "Could not open \"%s\"", opts->merged_input_name);
+        cleanup_state(retval, false);
+        return NULL;
+    }
+    if (retval->p.pool)
+        hts_set_opt(retval->merged_input_file, HTS_OPT_THREAD_POOL, &retval->p);
+    retval->merged_input_header = sam_hdr_read(retval->merged_input_file);
+    if (retval->merged_input_header == NULL) {
+        print_error("split", "Could not read header from \"%s\"", opts->merged_input_name);
+        cleanup_state(retval, false);
+        return NULL;
+    }
+
+    if (opts->unaccounted_name) {
+        if (opts->unaccounted_header_name) {
+            samFile* hdr_load = sam_open_format(opts->unaccounted_header_name, "r", &opts->ga.in);
+            if (!hdr_load) {
+                print_error_errno("split", "Could not open unaccounted header file \"%s\"", opts->unaccounted_header_name);
+                cleanup_state(retval, false);
+                return NULL;
+            }
+            retval->unaccounted_header = sam_hdr_read(hdr_load);
+            if (retval->unaccounted_header == NULL) {
+                print_error("split", "Could not read header from \"%s\"", opts->unaccounted_header_name);
+                cleanup_state(retval, false);
+                sam_close(hdr_load);
+                return NULL;
+            }
+            sam_close(hdr_load);
+            if (header_compatible(retval->merged_input_header,
+                                  retval->unaccounted_header) != 0) {
+                cleanup_state(retval, false);
+                return NULL;
+            }
+        } else {
+            retval->unaccounted_header = sam_hdr_dup(retval->merged_input_header);
+            if (!opts->no_pg && sam_hdr_add_pg(retval->unaccounted_header, "samtools",
+                                    "VN", samtools_version(),
+                                    arg_list ? "CL": NULL,
+                                    arg_list ? arg_list : NULL,
+                                    NULL)) {
+                print_error("split", "Could not rewrite header for \"%s\"", opts->unaccounted_name);
+                cleanup_state(retval, false);
+                return NULL;
+            }
+        }
+
+        char outmode[4] = "w";
+        sam_open_mode(outmode + 1, opts->unaccounted_name, NULL);
+        retval->unaccounted_file = sam_open_format(opts->unaccounted_name, outmode, &opts->ga.out);
+
+        if (retval->unaccounted_file == NULL) {
+            print_error_errno("split", "Could not open unaccounted output file \"%s\"", opts->unaccounted_name);
+            cleanup_state(retval, false);
+            return NULL;
+        }
+        if (retval->p.pool)
+            hts_set_opt(retval->unaccounted_file, HTS_OPT_THREAD_POOL, &retval->p);
+    }
+
+    // Open output files for RGs
+    if (!count_RG(retval->merged_input_header, &retval->output_count, &retval->rg_id)) return NULL;
+    if (opts->verbose) fprintf(stderr, "@RG's found %zu\n",retval->output_count);
+    // Prevent calloc(0, size);
+    size_t num = retval->output_count ? retval->output_count : 1;
+    retval->rg_index_file_name = (char **)calloc(num, sizeof(char *));
+    retval->rg_output_file_name = (char **)calloc(num, sizeof(char *));
+    retval->rg_output_file = (samFile**)calloc(num, sizeof(samFile*));
+    retval->rg_output_header = (sam_hdr_t**)calloc(num, sizeof(sam_hdr_t*));
+    retval->rg_hash = kh_init_c2i();
+    if (!retval->rg_output_file_name || !retval->rg_output_file || !retval->rg_output_header ||
+        !retval->rg_hash || !retval->rg_index_file_name) {
+        print_error_errno("split", "Could not initialise output file array");
+        cleanup_state(retval, false);
+        return NULL;
+    }
+
+    char* dirsep = strrchr(opts->merged_input_name, '/');
+    char* input_base_name = strdup(dirsep? dirsep+1 : opts->merged_input_name);
+    if (!input_base_name) {
+        print_error_errno("split", "Filename manipulation failed");
+        cleanup_state(retval, false);
+        return NULL;
+    }
+    char* extension = strrchr(input_base_name, '.');
+    if (extension) *extension = '\0';
+
+    size_t i;
+    for (i = 0; i < retval->output_count; i++) {
+        char* output_filename = NULL;
+        char outmode[4] = "w";
+
+        output_filename = expand_format_string(opts->output_format_string,
+                                               input_base_name,
+                                               retval->rg_id[i], i,
+                                               &opts->ga.out);
+
+        if ( output_filename == NULL ) {
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+
+        retval->rg_output_file_name[i] = output_filename;
+
+        sam_open_mode(outmode + 1, output_filename, NULL);
+        retval->rg_output_file[i] = sam_open_format(output_filename, outmode, &opts->ga.out);
+
+        if (retval->rg_output_file[i] == NULL) {
+            print_error_errno("split", "Could not open \"%s\"", output_filename);
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+        if (retval->p.pool)
+            hts_set_opt(retval->rg_output_file[i], HTS_OPT_THREAD_POOL, &retval->p);
+
+        // Record index in hash
+        int ret;
+        khiter_t iter = kh_put_c2i(retval->rg_hash, retval->rg_id[i], &ret);
+        if (ret < 0) {
+            print_error_errno("split", "Couldn't add @RG ID to look-up table");
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+        kh_val(retval->rg_hash,iter) = i;
+
+        // Set and edit header
+        retval->rg_output_header[i] = sam_hdr_dup(retval->merged_input_header);
+        if (sam_hdr_remove_except(retval->rg_output_header[i], "RG", "ID", retval->rg_id[i]) ||
+           (!opts->no_pg &&
+            sam_hdr_add_pg(retval->rg_output_header[i], "samtools",
+                        "VN", samtools_version(),
+                        arg_list ? "CL": NULL,
+                        arg_list ? arg_list : NULL,
+                        NULL))) {
+            print_error("split", "Could not rewrite header for \"%s\"", output_filename);
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+    }
+
+    free(input_base_name);
+    retval->write_index = opts->ga.write_index;
+
+    return retval;
+}
+
+static bool split(state_t* state)
+{
+    if (state->unaccounted_file && sam_hdr_write(state->unaccounted_file, state->unaccounted_header) != 0) {
+        print_error_errno("split", "Could not write output file header");
+        return false;
+    }
+    size_t i;
+    for (i = 0; i < state->output_count; i++) {
+        if (sam_hdr_write(state->rg_output_file[i], state->rg_output_header[i]) != 0) {
+            print_error_errno("split", "Could not write file header to \"%s\"", state->rg_output_file_name[i]);
+            return false;
+        }
+        if (state->write_index) {
+            state->rg_index_file_name[i] = auto_index(state->rg_output_file[i],
+                                                      state->rg_output_file_name[i],
+                                                      state->rg_output_header[i]);
+            if (!state->rg_index_file_name[i]) {
+                print_error_errno("split", "Could not create index for file \"%s\"", state->rg_output_file_name[i]);
+                return false;
+            }
+        }
+    }
+
+    bam1_t* file_read = bam_init1();
+    // Read the first record
+    int r;
+    if ((r=sam_read1(state->merged_input_file, state->merged_input_header, file_read)) < 0) {
+        // Nothing more to read?  Ignore this file
+        bam_destroy1(file_read);
+        file_read = NULL;
+        if (r < -1) {
+            print_error("split", "Could not read first input record");
+            return false;
+        }
+    }
+
+    while (file_read != NULL) {
+        // Get RG tag from read and look it up in hash to find file to output it to
+        uint8_t* tag = bam_aux_get(file_read, "RG");
+        khiter_t iter;
+        if ( tag != NULL ) {
+            char* rg = bam_aux2Z(tag);
+            iter = kh_get_c2i(state->rg_hash, rg);
+        } else {
+            iter = kh_end(state->rg_hash);
+        }
+
+        // Write the read out to correct file
+        if (iter != kh_end(state->rg_hash)) {
+            // if found write to the appropriate untangled bam
+            int i = kh_val(state->rg_hash,iter);
+            if (sam_write1(state->rg_output_file[i], state->rg_output_header[i], file_read) < 0) {
+                print_error_errno("split", "Could not write to \"%s\"", state->rg_output_file_name[i]);
+                bam_destroy1(file_read);
+                return false;
+            }
+        } else {
+            // otherwise write to the unaccounted bam if there is one or fail
+            if (state->unaccounted_file == NULL) {
+                if (tag) {
+                    fprintf(stderr, "Read \"%s\" with unaccounted for tag \"%s\".\n", bam_get_qname(file_read), bam_aux2Z(tag));
+                } else {
+                    fprintf(stderr, "Read \"%s\" has no RG tag.\n", bam_get_qname(file_read));
+                }
+                bam_destroy1(file_read);
+                return false;
+            } else {
+                if (sam_write1(state->unaccounted_file, state->unaccounted_header, file_read) < 0) {
+                    print_error_errno("split", "Could not write to unaccounted output file");
+                    bam_destroy1(file_read);
+                    return false;
+                }
+            }
+        }
+
+        // Replace written read with the next one to process
+        if ((r=sam_read1(state->merged_input_file, state->merged_input_header, file_read)) < 0) {
+            // Nothing more to read?  Ignore this file in future
+            bam_destroy1(file_read);
+            file_read = NULL;
+            if (r < -1) {
+                print_error("split", "Could not read input record");
+                return false;
+            }
+        }
+    }
+
+    if (state->write_index) {
+        for (i = 0; i < state->output_count; i++) {
+            if (sam_idx_save(state->rg_output_file[i]) < 0) {
+                print_error_errno("split", "writing index failed");
+                return false;
+            }
+            free(state->rg_index_file_name[i]);
+        }
+    }
+
+    return true;
+}
+
+static int cleanup_state(state_t* status, bool check_close)
+{
+    int ret = 0;
+
+    if (!status) return 0;
+    if (status->unaccounted_header) sam_hdr_destroy(status->unaccounted_header);
+    if (status->unaccounted_file) {
+        if (sam_close(status->unaccounted_file) < 0 && check_close) {
+            print_error("split", "Error on closing unaccounted file");
+            ret = -1;
+        }
+    }
+    sam_close(status->merged_input_file);
+    size_t i;
+    for (i = 0; i < status->output_count; i++) {
+        if (status->rg_output_header && status->rg_output_header[i])
+            sam_hdr_destroy(status->rg_output_header[i]);
+        if (status->rg_output_file && status->rg_output_file[i]) {
+            if (sam_close(status->rg_output_file[i]) < 0 && check_close) {
+                print_error("split", "Error on closing output file \"%s\"", status->rg_output_file_name[i]);
+                ret = -1;
+            }
+        }
+        if (status->rg_id) free(status->rg_id[i]);
+        if (status->rg_output_file_name) free(status->rg_output_file_name[i]);
+    }
+    if (status->merged_input_header)
+        sam_hdr_destroy(status->merged_input_header);
+    free(status->rg_output_header);
+    free(status->rg_output_file);
+    free(status->rg_output_file_name);
+    free(status->rg_index_file_name);
+    kh_destroy_c2i(status->rg_hash);
+    free(status->rg_id);
+    if (status->p.pool)
+        hts_tpool_destroy(status->p.pool);
+    free(status);
+
+    return ret;
+}
+
+static void cleanup_opts(parsed_opts_t* opts)
+{
+    if (!opts) return;
+    sam_global_args_free(&opts->ga);
+    free(opts);
+}
+
+int main_split(int argc, char** argv)
+{
+    int ret = 1;
+    char *arg_list = NULL;
+    parsed_opts_t* opts = parse_args(argc, argv);
+    if (!opts) goto cleanup_opts;
+    if (!opts->no_pg && !(arg_list = stringify_argv(argc+1, argv-1)))
+        goto cleanup_opts;
+    state_t* status = init(opts, arg_list);
+    if (!status) goto cleanup_opts;
+
+    if (!split(status)) {
+        cleanup_state(status, false);
+        goto cleanup_opts;
+    }
+
+    ret = cleanup_state(status, true);
+
+cleanup_opts:
+    cleanup_opts(opts);
+    free(arg_list);
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_split.c.pysam.c

@@ -0,0 +1,620 @@
+#include "samtools.pysam.h"
+
+/*  bam_split.c -- split subcommand.
+
+    Copyright (C) 2013-2016,2018-2019,2023 Genome Research Ltd.
+
+    Author: Martin Pollard <mp15@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <unistd.h>
+#include <regex.h>
+#include <assert.h>
+#include <htslib/sam.h>
+#include <htslib/khash.h>
+#include <htslib/kstring.h>
+#include <htslib/cram.h>
+#include "htslib/thread_pool.h"
+#include "sam_opts.h"
+#include "samtools.h"
+
+
+KHASH_MAP_INIT_STR(c2i, int)
+
+struct parsed_opts {
+    const char *merged_input_name;
+    const char *unaccounted_header_name;
+    const char *unaccounted_name;
+    const char *output_format_string;
+    bool verbose;
+    int no_pg;
+    sam_global_args ga;
+};
+
+typedef struct parsed_opts parsed_opts_t;
+
+struct state {
+    samFile* merged_input_file;
+    sam_hdr_t* merged_input_header;
+    samFile* unaccounted_file;
+    sam_hdr_t* unaccounted_header;
+    size_t output_count;
+    char** rg_id;
+    char **rg_index_file_name;
+    char **rg_output_file_name;
+    samFile** rg_output_file;
+    sam_hdr_t** rg_output_header;
+    kh_c2i_t* rg_hash;
+    htsThreadPool p;
+    int write_index;
+};
+
+typedef struct state state_t;
+
+static int cleanup_state(state_t* status, bool check_close);
+static void cleanup_opts(parsed_opts_t* opts);
+
+static void usage(FILE *write_to)
+{
+    fprintf(write_to,
+"Usage: samtools split [-u <unaccounted.bam>] [-h <unaccounted_header.sam>]\n"
+"                      [-f <format_string>] [-v] <merged.bam>\n"
+"Options:\n"
+"  -f STRING       output filename format string [\"%%*_%%#.%%.\"]\n"
+"  -u FILE1        put reads with no RG tag or an unrecognised RG tag in FILE1\n"
+"  -h FILE2        ... and override the header with FILE2 (-u file only)\n"
+"  -v              verbose output\n"
+"  --no-PG         do not add a PG line\n");
+    sam_global_opt_help(write_to, "-....@..");
+    fprintf(write_to,
+"\n"
+"Format string expansions:\n"
+"  %%%%     %%\n"
+"  %%*     basename\n"
+"  %%#     @RG index\n"
+"  %%!     @RG ID\n"
+"  %%.     filename extension for output format\n"
+      );
+}
+
+// Takes the command line options and turns them into something we can understand
+static parsed_opts_t* parse_args(int argc, char** argv)
+{
+    if (argc == 1) { usage(samtools_stdout); return NULL; }
+
+    const char *optstring = "vf:h:u:@:";
+
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 0, 0, 0, '@'),
+        {"no-PG", no_argument, NULL, 1},
+        { NULL, 0, NULL, 0 }
+    };
+
+    parsed_opts_t* retval = calloc(sizeof(parsed_opts_t), 1);
+    if (! retval ) { perror("cannot allocate option parsing memory"); return NULL; }
+
+    sam_global_args_init(&retval->ga);
+
+    int opt;
+    while ((opt = getopt_long(argc, argv, optstring, lopts, NULL)) != -1) {
+        switch (opt) {
+        case 'f':
+            retval->output_format_string = optarg;
+            break;
+        case 'h':
+            retval->unaccounted_header_name = optarg;
+            break;
+        case 'v':
+            retval->verbose = true;
+            break;
+        case 'u':
+            retval->unaccounted_name = optarg;
+            break;
+        case 1:
+            retval->no_pg = 1;
+            break;
+        default:
+            if (parse_sam_global_opt(opt, optarg, lopts, &retval->ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage(samtools_stdout);
+            free(retval);
+            return NULL;
+        }
+    }
+
+    if (retval->output_format_string == NULL) retval->output_format_string = "%*_%#.%.";
+
+    argc -= optind;
+    argv += optind;
+
+    if (argc != 1) {
+        print_error("split", "Invalid number of arguments: %d", argc);
+        usage(samtools_stderr);
+        free(retval);
+        return NULL;
+    }
+
+    retval->merged_input_name = argv[0];
+
+    return retval;
+}
+
+// Expands a output filename format string
+static char* expand_format_string(const char* format_string, const char* basename, const char* rg_id, const int rg_idx, const htsFormat *format)
+{
+    kstring_t str = { 0, 0, NULL };
+    const char* pointer = format_string;
+    const char* next;
+    while ((next = strchr(pointer, '%')) != NULL) {
+        if (kputsn(pointer, next-pointer, &str) < 0) goto memfail;
+        ++next;
+        switch (*next) {
+            case '%':
+                if (kputc('%', &str) < 0) goto memfail;
+                break;
+            case '*':
+                if (kputs(basename, &str) < 0) goto memfail;
+                break;
+            case '#':
+                if (kputl(rg_idx, &str) < 0) goto memfail;
+                break;
+            case '!':
+                if (kputs(rg_id, &str) < 0) goto memfail;
+                break;
+            case '.':
+                // Only really need to cope with sam, bam, cram
+                if (format->format != unknown_format) {
+                    if (kputs(hts_format_file_extension(format), &str) < 0)
+                        goto memfail;
+                } else {
+                    if (kputs("bam", &str) < 0) goto memfail;
+                }
+                break;
+            case '\0':
+                print_error("split", "Trailing %% in filename format string");
+                goto fail;
+            default:
+                // Error is: fprintf(samtools_stderr, "bad format string, unknown format specifier\n");
+                print_error("split", "Unknown specifier %%%c in filename format string", *next);
+                goto fail;
+        }
+        pointer = next + 1;
+    }
+    if (kputs(pointer, &str) < 0) goto memfail;
+    return ks_release(&str);
+
+ memfail:
+    print_error_errno("split", "Couldn't build output filename");
+ fail:
+    free(str.s);
+    return NULL;
+}
+
+// Parse the header, count the number of RG tags and return a list of their names
+static bool count_RG(sam_hdr_t* hdr, size_t* count, char*** output_name)
+{
+    char **names = NULL;
+    kstring_t id_val = KS_INITIALIZE;
+    int i, n_rg = sam_hdr_count_lines(hdr, "RG");
+
+    if (n_rg < 0) {
+        print_error("split", "Failed to get @RG IDs");
+        *count = 0;
+        *output_name = NULL;
+        return false;
+    }
+
+    if (n_rg == 0) {
+        *count = 0;
+        *output_name = NULL;
+        return true;
+    }
+
+    names = calloc(n_rg, sizeof(names[0]));
+    if (!names) goto memfail;
+
+    for (i = 0; i < n_rg; i++) {
+        if (sam_hdr_find_tag_pos(hdr, "RG", i, "ID", &id_val) < 0) goto memfail;
+        names[i] = ks_release(&id_val);
+    }
+
+    *count = n_rg;
+    *output_name = names;
+    return true;
+
+ memfail:
+    print_error_errno("split", "Failed to get @RG IDs");
+    *count = 0;
+    *output_name = NULL;
+    ks_free(&id_val);
+    free(names);
+    return false;
+}
+
+static int header_compatible(sam_hdr_t *hdr1, sam_hdr_t *hdr2)
+{
+    size_t n;
+    if (sam_hdr_nref(hdr1) != sam_hdr_nref(hdr2)) {
+        print_error("split",
+                    "Unaccounted header contains wrong number of references");
+        return -1;
+    }
+    for (n = 0; n < sam_hdr_nref(hdr1); n++) {
+        hts_pos_t h1_len = sam_hdr_tid2len(hdr1, n);
+        hts_pos_t h2_len = sam_hdr_tid2len(hdr2, n);
+        if (h1_len != h2_len) {
+            print_error("split",
+                        "Unaccounted header reference %zu \"%s\" is not the same length as in the input file",
+                        n + 1, sam_hdr_tid2name(hdr2, n));
+            return -1;
+        }
+    }
+    return 0;
+}
+
+// Set the initial state
+static state_t* init(parsed_opts_t* opts, const char *arg_list)
+{
+    state_t* retval = calloc(sizeof(state_t), 1);
+    if (!retval) {
+        print_error_errno("split", "Initialisation failed");
+        return NULL;
+    }
+
+    if (opts->ga.nthreads > 0) {
+        if (!(retval->p.pool = hts_tpool_init(opts->ga.nthreads))) {
+            fprintf(samtools_stderr, "Error creating thread pool\n");
+            cleanup_state(retval, false);
+            return NULL;
+        }
+    }
+
+    retval->merged_input_file = sam_open_format(opts->merged_input_name, "r", &opts->ga.in);
+    if (!retval->merged_input_file) {
+        print_error_errno("split", "Could not open \"%s\"", opts->merged_input_name);
+        cleanup_state(retval, false);
+        return NULL;
+    }
+    if (retval->p.pool)
+        hts_set_opt(retval->merged_input_file, HTS_OPT_THREAD_POOL, &retval->p);
+    retval->merged_input_header = sam_hdr_read(retval->merged_input_file);
+    if (retval->merged_input_header == NULL) {
+        print_error("split", "Could not read header from \"%s\"", opts->merged_input_name);
+        cleanup_state(retval, false);
+        return NULL;
+    }
+
+    if (opts->unaccounted_name) {
+        if (opts->unaccounted_header_name) {
+            samFile* hdr_load = sam_open_format(opts->unaccounted_header_name, "r", &opts->ga.in);
+            if (!hdr_load) {
+                print_error_errno("split", "Could not open unaccounted header file \"%s\"", opts->unaccounted_header_name);
+                cleanup_state(retval, false);
+                return NULL;
+            }
+            retval->unaccounted_header = sam_hdr_read(hdr_load);
+            if (retval->unaccounted_header == NULL) {
+                print_error("split", "Could not read header from \"%s\"", opts->unaccounted_header_name);
+                cleanup_state(retval, false);
+                sam_close(hdr_load);
+                return NULL;
+            }
+            sam_close(hdr_load);
+            if (header_compatible(retval->merged_input_header,
+                                  retval->unaccounted_header) != 0) {
+                cleanup_state(retval, false);
+                return NULL;
+            }
+        } else {
+            retval->unaccounted_header = sam_hdr_dup(retval->merged_input_header);
+            if (!opts->no_pg && sam_hdr_add_pg(retval->unaccounted_header, "samtools",
+                                    "VN", samtools_version(),
+                                    arg_list ? "CL": NULL,
+                                    arg_list ? arg_list : NULL,
+                                    NULL)) {
+                print_error("split", "Could not rewrite header for \"%s\"", opts->unaccounted_name);
+                cleanup_state(retval, false);
+                return NULL;
+            }
+        }
+
+        char outmode[4] = "w";
+        sam_open_mode(outmode + 1, opts->unaccounted_name, NULL);
+        retval->unaccounted_file = sam_open_format(opts->unaccounted_name, outmode, &opts->ga.out);
+
+        if (retval->unaccounted_file == NULL) {
+            print_error_errno("split", "Could not open unaccounted output file \"%s\"", opts->unaccounted_name);
+            cleanup_state(retval, false);
+            return NULL;
+        }
+        if (retval->p.pool)
+            hts_set_opt(retval->unaccounted_file, HTS_OPT_THREAD_POOL, &retval->p);
+    }
+
+    // Open output files for RGs
+    if (!count_RG(retval->merged_input_header, &retval->output_count, &retval->rg_id)) return NULL;
+    if (opts->verbose) fprintf(samtools_stderr, "@RG's found %zu\n",retval->output_count);
+    // Prevent calloc(0, size);
+    size_t num = retval->output_count ? retval->output_count : 1;
+    retval->rg_index_file_name = (char **)calloc(num, sizeof(char *));
+    retval->rg_output_file_name = (char **)calloc(num, sizeof(char *));
+    retval->rg_output_file = (samFile**)calloc(num, sizeof(samFile*));
+    retval->rg_output_header = (sam_hdr_t**)calloc(num, sizeof(sam_hdr_t*));
+    retval->rg_hash = kh_init_c2i();
+    if (!retval->rg_output_file_name || !retval->rg_output_file || !retval->rg_output_header ||
+        !retval->rg_hash || !retval->rg_index_file_name) {
+        print_error_errno("split", "Could not initialise output file array");
+        cleanup_state(retval, false);
+        return NULL;
+    }
+
+    char* dirsep = strrchr(opts->merged_input_name, '/');
+    char* input_base_name = strdup(dirsep? dirsep+1 : opts->merged_input_name);
+    if (!input_base_name) {
+        print_error_errno("split", "Filename manipulation failed");
+        cleanup_state(retval, false);
+        return NULL;
+    }
+    char* extension = strrchr(input_base_name, '.');
+    if (extension) *extension = '\0';
+
+    size_t i;
+    for (i = 0; i < retval->output_count; i++) {
+        char* output_filename = NULL;
+        char outmode[4] = "w";
+
+        output_filename = expand_format_string(opts->output_format_string,
+                                               input_base_name,
+                                               retval->rg_id[i], i,
+                                               &opts->ga.out);
+
+        if ( output_filename == NULL ) {
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+
+        retval->rg_output_file_name[i] = output_filename;
+
+        sam_open_mode(outmode + 1, output_filename, NULL);
+        retval->rg_output_file[i] = sam_open_format(output_filename, outmode, &opts->ga.out);
+
+        if (retval->rg_output_file[i] == NULL) {
+            print_error_errno("split", "Could not open \"%s\"", output_filename);
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+        if (retval->p.pool)
+            hts_set_opt(retval->rg_output_file[i], HTS_OPT_THREAD_POOL, &retval->p);
+
+        // Record index in hash
+        int ret;
+        khiter_t iter = kh_put_c2i(retval->rg_hash, retval->rg_id[i], &ret);
+        if (ret < 0) {
+            print_error_errno("split", "Couldn't add @RG ID to look-up table");
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+        kh_val(retval->rg_hash,iter) = i;
+
+        // Set and edit header
+        retval->rg_output_header[i] = sam_hdr_dup(retval->merged_input_header);
+        if (sam_hdr_remove_except(retval->rg_output_header[i], "RG", "ID", retval->rg_id[i]) ||
+           (!opts->no_pg &&
+            sam_hdr_add_pg(retval->rg_output_header[i], "samtools",
+                        "VN", samtools_version(),
+                        arg_list ? "CL": NULL,
+                        arg_list ? arg_list : NULL,
+                        NULL))) {
+            print_error("split", "Could not rewrite header for \"%s\"", output_filename);
+            cleanup_state(retval, false);
+            free(input_base_name);
+            return NULL;
+        }
+    }
+
+    free(input_base_name);
+    retval->write_index = opts->ga.write_index;
+
+    return retval;
+}
+
+static bool split(state_t* state)
+{
+    if (state->unaccounted_file && sam_hdr_write(state->unaccounted_file, state->unaccounted_header) != 0) {
+        print_error_errno("split", "Could not write output file header");
+        return false;
+    }
+    size_t i;
+    for (i = 0; i < state->output_count; i++) {
+        if (sam_hdr_write(state->rg_output_file[i], state->rg_output_header[i]) != 0) {
+            print_error_errno("split", "Could not write file header to \"%s\"", state->rg_output_file_name[i]);
+            return false;
+        }
+        if (state->write_index) {
+            state->rg_index_file_name[i] = auto_index(state->rg_output_file[i],
+                                                      state->rg_output_file_name[i],
+                                                      state->rg_output_header[i]);
+            if (!state->rg_index_file_name[i]) {
+                print_error_errno("split", "Could not create index for file \"%s\"", state->rg_output_file_name[i]);
+                return false;
+            }
+        }
+    }
+
+    bam1_t* file_read = bam_init1();
+    // Read the first record
+    int r;
+    if ((r=sam_read1(state->merged_input_file, state->merged_input_header, file_read)) < 0) {
+        // Nothing more to read?  Ignore this file
+        bam_destroy1(file_read);
+        file_read = NULL;
+        if (r < -1) {
+            print_error("split", "Could not read first input record");
+            return false;
+        }
+    }
+
+    while (file_read != NULL) {
+        // Get RG tag from read and look it up in hash to find file to output it to
+        uint8_t* tag = bam_aux_get(file_read, "RG");
+        khiter_t iter;
+        if ( tag != NULL ) {
+            char* rg = bam_aux2Z(tag);
+            iter = kh_get_c2i(state->rg_hash, rg);
+        } else {
+            iter = kh_end(state->rg_hash);
+        }
+
+        // Write the read out to correct file
+        if (iter != kh_end(state->rg_hash)) {
+            // if found write to the appropriate untangled bam
+            int i = kh_val(state->rg_hash,iter);
+            if (sam_write1(state->rg_output_file[i], state->rg_output_header[i], file_read) < 0) {
+                print_error_errno("split", "Could not write to \"%s\"", state->rg_output_file_name[i]);
+                bam_destroy1(file_read);
+                return false;
+            }
+        } else {
+            // otherwise write to the unaccounted bam if there is one or fail
+            if (state->unaccounted_file == NULL) {
+                if (tag) {
+                    fprintf(samtools_stderr, "Read \"%s\" with unaccounted for tag \"%s\".\n", bam_get_qname(file_read), bam_aux2Z(tag));
+                } else {
+                    fprintf(samtools_stderr, "Read \"%s\" has no RG tag.\n", bam_get_qname(file_read));
+                }
+                bam_destroy1(file_read);
+                return false;
+            } else {
+                if (sam_write1(state->unaccounted_file, state->unaccounted_header, file_read) < 0) {
+                    print_error_errno("split", "Could not write to unaccounted output file");
+                    bam_destroy1(file_read);
+                    return false;
+                }
+            }
+        }
+
+        // Replace written read with the next one to process
+        if ((r=sam_read1(state->merged_input_file, state->merged_input_header, file_read)) < 0) {
+            // Nothing more to read?  Ignore this file in future
+            bam_destroy1(file_read);
+            file_read = NULL;
+            if (r < -1) {
+                print_error("split", "Could not read input record");
+                return false;
+            }
+        }
+    }
+
+    if (state->write_index) {
+        for (i = 0; i < state->output_count; i++) {
+            if (sam_idx_save(state->rg_output_file[i]) < 0) {
+                print_error_errno("split", "writing index failed");
+                return false;
+            }
+            free(state->rg_index_file_name[i]);
+        }
+    }
+
+    return true;
+}
+
+static int cleanup_state(state_t* status, bool check_close)
+{
+    int ret = 0;
+
+    if (!status) return 0;
+    if (status->unaccounted_header) sam_hdr_destroy(status->unaccounted_header);
+    if (status->unaccounted_file) {
+        if (sam_close(status->unaccounted_file) < 0 && check_close) {
+            print_error("split", "Error on closing unaccounted file");
+            ret = -1;
+        }
+    }
+    sam_close(status->merged_input_file);
+    size_t i;
+    for (i = 0; i < status->output_count; i++) {
+        if (status->rg_output_header && status->rg_output_header[i])
+            sam_hdr_destroy(status->rg_output_header[i]);
+        if (status->rg_output_file && status->rg_output_file[i]) {
+            if (sam_close(status->rg_output_file[i]) < 0 && check_close) {
+                print_error("split", "Error on closing output file \"%s\"", status->rg_output_file_name[i]);
+                ret = -1;
+            }
+        }
+        if (status->rg_id) free(status->rg_id[i]);
+        if (status->rg_output_file_name) free(status->rg_output_file_name[i]);
+    }
+    if (status->merged_input_header)
+        sam_hdr_destroy(status->merged_input_header);
+    free(status->rg_output_header);
+    free(status->rg_output_file);
+    free(status->rg_output_file_name);
+    free(status->rg_index_file_name);
+    kh_destroy_c2i(status->rg_hash);
+    free(status->rg_id);
+    if (status->p.pool)
+        hts_tpool_destroy(status->p.pool);
+    free(status);
+
+    return ret;
+}
+
+static void cleanup_opts(parsed_opts_t* opts)
+{
+    if (!opts) return;
+    sam_global_args_free(&opts->ga);
+    free(opts);
+}
+
+int main_split(int argc, char** argv)
+{
+    int ret = 1;
+    char *arg_list = NULL;
+    parsed_opts_t* opts = parse_args(argc, argv);
+    if (!opts) goto cleanup_opts;
+    if (!opts->no_pg && !(arg_list = stringify_argv(argc+1, argv-1)))
+        goto cleanup_opts;
+    state_t* status = init(opts, arg_list);
+    if (!status) goto cleanup_opts;
+
+    if (!split(status)) {
+        cleanup_state(status, false);
+        goto cleanup_opts;
+    }
+
+    ret = cleanup_state(status, true);
+
+cleanup_opts:
+    cleanup_opts(opts);
+    free(arg_list);
+
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bam_stat.c

@@ -0,0 +1,346 @@
+/*  bam_stat.c -- flagstat subcommand.
+
+    Copyright (C) 2009, 2011, 2013-2015, 2019, 2021 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <limits.h>
+#include <getopt.h>
+
+#include "htslib/sam.h"
+#include "samtools.h"
+#include "sam_opts.h"
+
+typedef struct {
+    long long n_reads[2], n_mapped[2], n_pair_all[2], n_pair_map[2], n_pair_good[2];
+    long long n_sgltn[2], n_read1[2], n_read2[2];
+    long long n_dup[2];
+    long long n_diffchr[2], n_diffhigh[2];
+    long long n_secondary[2], n_supp[2];
+    long long n_primary[2], n_pmapped[2], n_pdup[2];
+} bam_flagstat_t;
+
+inline static void flagstat_loop(bam_flagstat_t *s, bam1_core_t *c)
+{
+    int w = (c->flag & BAM_FQCFAIL)? 1 : 0;
+    ++s->n_reads[w];
+    if (c->flag & BAM_FSECONDARY ) {
+        ++s->n_secondary[w];
+    } else if (c->flag & BAM_FSUPPLEMENTARY ) {
+        ++s->n_supp[w];
+    } else {
+        ++s->n_primary[w];
+
+        if (c->flag & BAM_FPAIRED) {
+            ++s->n_pair_all[w];
+            if ((c->flag & BAM_FPROPER_PAIR) && !(c->flag & BAM_FUNMAP) ) ++s->n_pair_good[w];
+            if (c->flag & BAM_FREAD1) ++s->n_read1[w];
+            if (c->flag & BAM_FREAD2) ++s->n_read2[w];
+            if ((c->flag & BAM_FMUNMAP) && !(c->flag & BAM_FUNMAP)) ++s->n_sgltn[w];
+            if (!(c->flag & BAM_FUNMAP) && !(c->flag & BAM_FMUNMAP)) {
+                ++s->n_pair_map[w];
+                if (c->mtid != c->tid) {
+                    ++s->n_diffchr[w];
+                    if (c->qual >= 5) ++s->n_diffhigh[w];
+                }
+            }
+        }
+
+        if (!(c->flag & BAM_FUNMAP)) ++s->n_pmapped[w];
+        if (c->flag & BAM_FDUP) ++s->n_pdup[w];
+    }
+    if (!(c->flag & BAM_FUNMAP)) ++s->n_mapped[w];
+    if (c->flag & BAM_FDUP) ++s->n_dup[w];
+}
+
+bam_flagstat_t *bam_flagstat_core(samFile *fp, sam_hdr_t *h)
+{
+    bam_flagstat_t *s;
+    bam1_t *b;
+    bam1_core_t *c;
+    int ret;
+    s = (bam_flagstat_t*)calloc(1, sizeof(bam_flagstat_t));
+    b = bam_init1();
+    c = &b->core;
+    while ((ret = sam_read1(fp, h, b)) >= 0)
+        flagstat_loop(s, c);
+    bam_destroy1(b);
+    if (ret != -1) {
+        free(s);
+        return NULL;
+    }
+    return s;
+}
+
+static const char *percent(char *buffer, long long n, long long total)
+{
+    if (total != 0) sprintf(buffer, "%.2f%%", (float)n / total * 100.0);
+    else strcpy(buffer, "N/A");
+    return buffer;
+}
+
+static const char *percent_json(char *buffer, long long n, long long total)
+{
+    if (total != 0) sprintf(buffer, "%.2f", (float)n / total * 100.0);
+    else strcpy(buffer, "null");
+    return buffer;
+}
+
+static void usage_exit(FILE *fp, int exit_status)
+{
+    fprintf(fp, "Usage: samtools flagstat [options] <in.bam>\n");
+    sam_global_opt_help(fp, "-.---@-.");
+    fprintf(fp, "  -O, --");
+    fprintf(fp, "output-fmt FORMAT[,OPT[=VAL]]...\n"
+            "               Specify output format (json, tsv)\n");
+    exit(exit_status);
+}
+
+static void out_fmt_default(bam_flagstat_t *s)
+{
+    char b0[16], b1[16];
+    printf("%lld + %lld in total (QC-passed reads + QC-failed reads)\n", s->n_reads[0], s->n_reads[1]);
+    printf("%lld + %lld primary\n", s->n_primary[0], s->n_primary[1]);
+    printf("%lld + %lld secondary\n", s->n_secondary[0], s->n_secondary[1]);
+    printf("%lld + %lld supplementary\n", s->n_supp[0], s->n_supp[1]);
+    printf("%lld + %lld duplicates\n", s->n_dup[0], s->n_dup[1]);
+    printf("%lld + %lld primary duplicates\n", s->n_pdup[0], s->n_pdup[1]);
+    printf("%lld + %lld mapped (%s : %s)\n", s->n_mapped[0], s->n_mapped[1], percent(b0, s->n_mapped[0], s->n_reads[0]), percent(b1, s->n_mapped[1], s->n_reads[1]));
+    printf("%lld + %lld primary mapped (%s : %s)\n", s->n_pmapped[0], s->n_pmapped[1], percent(b0, s->n_pmapped[0], s->n_primary[0]), percent(b1, s->n_pmapped[1], s->n_primary[1]));
+    printf("%lld + %lld paired in sequencing\n", s->n_pair_all[0], s->n_pair_all[1]);
+    printf("%lld + %lld read1\n", s->n_read1[0], s->n_read1[1]);
+    printf("%lld + %lld read2\n", s->n_read2[0], s->n_read2[1]);
+    printf("%lld + %lld properly paired (%s : %s)\n", s->n_pair_good[0], s->n_pair_good[1], percent(b0, s->n_pair_good[0], s->n_pair_all[0]), percent(b1, s->n_pair_good[1], s->n_pair_all[1]));
+    printf("%lld + %lld with itself and mate mapped\n", s->n_pair_map[0], s->n_pair_map[1]);
+    printf("%lld + %lld singletons (%s : %s)\n", s->n_sgltn[0], s->n_sgltn[1], percent(b0, s->n_sgltn[0], s->n_pair_all[0]), percent(b1, s->n_sgltn[1], s->n_pair_all[1]));
+    printf("%lld + %lld with mate mapped to a different chr\n", s->n_diffchr[0], s->n_diffchr[1]);
+    printf("%lld + %lld with mate mapped to a different chr (mapQ>=5)\n", s->n_diffhigh[0], s->n_diffhigh[1]);
+}
+
+static void out_fmt_json(bam_flagstat_t *s) {
+    char b0[16], b1[16], p0[16], p1[16], pp0[16], pp1[16], s0[16], s1[16];
+    printf("{\n \"QC-passed reads\": { \n"
+                 "  \"total\": %lld, \n"
+                 "  \"primary\": %lld, \n"
+                 "  \"secondary\": %lld, \n"
+                 "  \"supplementary\": %lld, \n"
+                 "  \"duplicates\": %lld, \n"
+                 "  \"primary duplicates\": %lld, \n"
+                 "  \"mapped\": %lld, \n"
+                 "  \"mapped %%\": %s, \n"
+                 "  \"primary mapped\": %lld, \n"
+                 "  \"primary mapped %%\": %s, \n"
+                 "  \"paired in sequencing\": %lld, \n"
+                 "  \"read1\": %lld, \n"
+                 "  \"read2\": %lld, \n"
+                 "  \"properly paired\": %lld, \n"
+                 "  \"properly paired %%\": %s, \n"
+                 "  \"with itself and mate mapped\": %lld, \n"
+                 "  \"singletons\": %lld, \n"
+                 "  \"singletons %%\": %s, \n"
+                 "  \"with mate mapped to a different chr\": %lld, \n"
+                 "  \"with mate mapped to a different chr (mapQ >= 5)\": %lld \n"
+                 " },"
+            "\n \"QC-failed reads\": { \n"
+                 "  \"total\": %lld, \n"
+                 "  \"primary\": %lld, \n"
+                 "  \"secondary\": %lld, \n"
+                 "  \"supplementary\": %lld, \n"
+                 "  \"duplicates\": %lld, \n"
+                 "  \"primary duplicates\": %lld, \n"
+                 "  \"mapped\": %lld, \n"
+                 "  \"mapped %%\": %s, \n"
+                 "  \"primary mapped\": %lld, \n"
+                 "  \"primary mapped %%\": %s, \n"
+                 "  \"paired in sequencing\": %lld, \n"
+                 "  \"read1\": %lld, \n"
+                 "  \"read2\": %lld, \n"
+                 "  \"properly paired\": %lld, \n"
+                 "  \"properly paired %%\": %s, \n"
+                 "  \"with itself and mate mapped\": %lld, \n"
+                 "  \"singletons\": %lld, \n"
+                 "  \"singletons %%\": %s, \n"
+                 "  \"with mate mapped to a different chr\": %lld, \n"
+                 "  \"with mate mapped to a different chr (mapQ >= 5)\": %lld \n"
+                 " }\n"
+            "}\n",
+        s->n_reads[0],
+        s->n_primary[0],
+        s->n_secondary[0],
+        s->n_supp[0],
+        s->n_dup[0],
+        s->n_pdup[0],
+        s->n_mapped[0],
+        percent_json(b0, s->n_mapped[0], s->n_reads[0]),
+        s->n_pmapped[0],
+        percent_json(p0, s->n_pmapped[0], s->n_primary[0]),
+        s->n_pair_all[0],
+        s->n_read1[0],
+        s->n_read2[0],
+        s->n_pair_good[0],
+        percent_json(pp0, s->n_pair_good[0], s->n_pair_all[0]),
+        s->n_pair_map[0],
+        s->n_sgltn[0],
+        percent_json(s0, s->n_sgltn[0], s->n_pair_all[0]),
+        s->n_diffchr[0],
+        s->n_diffhigh[0],
+        s->n_reads[1],
+        s->n_primary[1],
+        s->n_secondary[1],
+        s->n_supp[1],
+        s->n_dup[1],
+        s->n_pdup[1],
+        s->n_mapped[1],
+        percent_json(b1, s->n_mapped[1], s->n_reads[1]),
+        s->n_pmapped[1],
+        percent_json(p1, s->n_pmapped[1], s->n_primary[1]),
+        s->n_pair_all[1],
+        s->n_read1[1],
+        s->n_read2[1],
+        s->n_pair_good[1],
+        percent_json(pp1, s->n_pair_good[1], s->n_pair_all[1]),
+        s->n_pair_map[1],
+        s->n_sgltn[1],
+        percent_json(s1, s->n_sgltn[1], s->n_pair_all[1]),
+        s->n_diffchr[1],
+        s->n_diffhigh[1]
+    );
+}
+
+static void out_fmt_tsv(bam_flagstat_t *s) {
+    char b0[16], b1[16];
+    printf("%lld\t%lld\ttotal (QC-passed reads + QC-failed reads)\n", s->n_reads[0], s->n_reads[1]);
+    printf("%lld\t%lld\tprimary\n", s->n_primary[0], s->n_primary[1]);
+    printf("%lld\t%lld\tsecondary\n", s->n_secondary[0], s->n_secondary[1]);
+    printf("%lld\t%lld\tsupplementary\n", s->n_supp[0], s->n_supp[1]);
+    printf("%lld\t%lld\tduplicates\n", s->n_dup[0], s->n_dup[1]);
+    printf("%lld\t%lld\tprimary duplicates\n", s->n_pdup[0], s->n_pdup[1]);
+    printf("%lld\t%lld\tmapped\n", s->n_mapped[0], s->n_mapped[1]);
+    printf("%s\t%s\tmapped %%\n", percent(b0, s->n_mapped[0], s->n_reads[0]), percent(b1, s->n_mapped[1], s->n_reads[1]));
+    printf("%lld\t%lld\tprimary mapped\n", s->n_pmapped[0], s->n_pmapped[1]);
+    printf("%s\t%s\tprimary mapped %%\n", percent(b0, s->n_pmapped[0], s->n_primary[0]), percent(b1, s->n_pmapped[1], s->n_primary[1]));
+    printf("%lld\t%lld\tpaired in sequencing\n", s->n_pair_all[0], s->n_pair_all[1]);
+    printf("%lld\t%lld\tread1\n", s->n_read1[0], s->n_read1[1]);
+    printf("%lld\t%lld\tread2\n", s->n_read2[0], s->n_read2[1]);
+    printf("%lld\t%lld\tproperly paired\n", s->n_pair_good[0], s->n_pair_good[1]);
+    printf("%s\t%s\tproperly paired %%\n", percent(b0, s->n_pair_good[0], s->n_pair_all[0]), percent(b1, s->n_pair_good[1], s->n_pair_all[1]));
+    printf("%lld\t%lld\twith itself and mate mapped\n", s->n_pair_map[0], s->n_pair_map[1]);
+    printf("%lld\t%lld\tsingletons\n", s->n_sgltn[0], s->n_sgltn[1]);
+    printf("%s\t%s\tsingletons %%\n", percent(b0, s->n_sgltn[0], s->n_pair_all[0]), percent(b1, s->n_sgltn[1], s->n_pair_all[1]));
+    printf("%lld\t%lld\twith mate mapped to a different chr\n", s->n_diffchr[0], s->n_diffchr[1]);
+    printf("%lld\t%lld\twith mate mapped to a different chr (mapQ>=5)\n", s->n_diffhigh[0], s->n_diffhigh[1]);
+}
+
+/*
+ * Select flagstats output format to print.
+ */
+static void output_fmt(bam_flagstat_t *s, const char *out_fmt)
+{
+  if (strcmp(out_fmt, "json") == 0 || strcmp(out_fmt, "JSON") == 0) {
+    out_fmt_json(s);
+  } else if (strcmp(out_fmt, "tsv") == 0 || strcmp(out_fmt, "TSV") == 0) {
+    out_fmt_tsv(s);
+  } else {
+    out_fmt_default(s);
+  }
+}
+
+int bam_flagstat(int argc, char *argv[])
+{
+    samFile *fp;
+    sam_hdr_t *header;
+    bam_flagstat_t *s;
+    const char *out_fmt = "default";
+    int c, status = EXIT_SUCCESS;
+
+    enum {
+        INPUT_FMT_OPTION = CHAR_MAX+1,
+    };
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, 'O', '-', '-', '@'),
+        {NULL, 0, NULL, 0}
+    };
+
+    while ((c = getopt_long(argc, argv, "@:O:", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'O':
+          out_fmt = optarg;
+          break;
+        default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?':
+            usage_exit(stderr, EXIT_FAILURE);
+        }
+    }
+
+    if (argc != optind+1) {
+        if (argc == optind) usage_exit(stdout, EXIT_SUCCESS);
+        else usage_exit(stderr, EXIT_FAILURE);
+    }
+    fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (fp == NULL) {
+        print_error_errno("flagstat", "Cannot open input file \"%s\"", argv[optind]);
+        return 1;
+    }
+    if (ga.nthreads > 0)
+        hts_set_threads(fp, ga.nthreads);
+
+    if (hts_set_opt(fp, CRAM_OPT_REQUIRED_FIELDS,
+                    SAM_FLAG | SAM_MAPQ | SAM_RNEXT)) {
+        fprintf(stderr, "Failed to set CRAM_OPT_REQUIRED_FIELDS value\n");
+        return 1;
+    }
+
+    if (hts_set_opt(fp, CRAM_OPT_DECODE_MD, 0)) {
+        fprintf(stderr, "Failed to set CRAM_OPT_DECODE_MD value\n");
+        return 1;
+    }
+
+    header = sam_hdr_read(fp);
+    if (header == NULL) {
+        fprintf(stderr, "Failed to read header for \"%s\"\n", argv[optind]);
+        return 1;
+    }
+
+    s = bam_flagstat_core(fp, header);
+    if (s) {
+        output_fmt(s, out_fmt);
+        free(s);
+    }
+    else {
+        print_error("flagstat", "error reading from \"%s\"", argv[optind]);
+        status = EXIT_FAILURE;
+    }
+
+    sam_hdr_destroy(header);
+    sam_close(fp);
+    sam_global_args_free(&ga);
+    return status;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bamtk.c

@@ -0,0 +1,307 @@
+/*  bamtk.c -- main samtools command front-end.
+
+    Copyright (C) 2008-2023 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "htslib/hts.h"
+#include "htslib/hfile.h"
+#include "samtools.h"
+#include "version.h"
+
+int bam_taf2baf(int argc, char *argv[]);
+int bam_mpileup(int argc, char *argv[]);
+int bam_merge(int argc, char *argv[]);
+int bam_index(int argc, char *argv[]);
+int bam_sort(int argc, char *argv[]);
+int bam_tview_main(int argc, char *argv[]);
+int bam_mating(int argc, char *argv[]);
+int bam_rmdup(int argc, char *argv[]);
+int bam_flagstat(int argc, char *argv[]);
+int bam_fillmd(int argc, char *argv[]);
+int bam_idxstats(int argc, char *argv[]);
+int bam_markdup(int argc, char *argv[]);
+int main_samview(int argc, char *argv[]);
+int main_head(int argc, char *argv[]);
+int main_reheader(int argc, char *argv[]);
+int main_cut_target(int argc, char *argv[]);
+int main_phase(int argc, char *argv[]);
+int main_cat(int argc, char *argv[]);
+int main_depth(int argc, char *argv[]);
+int main_coverage(int argc, char *argv[]);
+int main_bam2fq(int argc, char *argv[]);
+int main_pad2unpad(int argc, char *argv[]);
+int main_bedcov(int argc, char *argv[]);
+int main_bamshuf(int argc, char *argv[]);
+int main_stats(int argc, char *argv[]);
+int main_flags(int argc, char *argv[]);
+int main_split(int argc, char *argv[]);
+int main_quickcheck(int argc, char *argv[]);
+int main_addreplacerg(int argc, char *argv[]);
+int faidx_main(int argc, char *argv[]);
+int dict_main(int argc, char *argv[]);
+int fqidx_main(int argc, char *argv[]);
+int amplicon_clip_main(int argc, char *argv[]);
+int main_ampliconstats(int argc, char *argv[]);
+int main_import(int argc, char *argv[]);
+int main_samples(int argc, char *argv[]);
+int main_consensus(int argc, char *argv[]);
+int main_reference(int argc, char *argv[]);
+int main_reset(int argc, char *argv[]);
+int main_cram_size(int argc, char *argv[]);
+
+const char *samtools_version()
+{
+    return SAMTOOLS_VERSION;
+}
+
+// These come out of the config.h file built by autoconf or Makefile
+const char *samtools_feature_string(void) {
+    const char *fmt =
+
+#ifdef PACKAGE_URL
+    "build=configure "
+#else
+    "build=Makefile "
+#endif
+
+#ifdef HAVE_CURSES
+    "curses=yes "
+#else
+    "curses=no "
+#endif
+    ;
+
+    return fmt;
+}
+
+static void long_version(void) {
+    printf("samtools %s\n"
+           "Using htslib %s\n"
+           "Copyright (C) 2023 Genome Research Ltd.\n",
+           samtools_version(), hts_version());
+
+    printf("\nSamtools compilation details:\n");
+    printf("    Features:       %s\n", samtools_feature_string());
+    printf("    CC:             %s\n", SAMTOOLS_CC);
+    printf("    CPPFLAGS:       %s\n", SAMTOOLS_CPPFLAGS);
+    printf("    CFLAGS:         %s\n", SAMTOOLS_CFLAGS);
+    printf("    LDFLAGS:        %s\n", SAMTOOLS_LDFLAGS);
+    printf("    HTSDIR:         %s\n", SAMTOOLS_HTSDIR);
+    printf("    LIBS:           %s\n", SAMTOOLS_LIBS);
+    printf("    CURSES_LIB:     %s\n", SAMTOOLS_CURSES_LIB);
+
+    printf("\nHTSlib compilation details:\n");
+    printf("    Features:       %s\n", hts_feature_string());
+    printf("    CC:             %s\n", hts_test_feature(HTS_FEATURE_CC));
+    printf("    CPPFLAGS:       %s\n", hts_test_feature(HTS_FEATURE_CPPFLAGS));
+    printf("    CFLAGS:         %s\n", hts_test_feature(HTS_FEATURE_CFLAGS));
+    printf("    LDFLAGS:        %s\n", hts_test_feature(HTS_FEATURE_LDFLAGS));
+
+    // Plugins and schemes
+    printf("\nHTSlib URL scheme handlers present:\n");
+    const char *plugins[100];
+    int np = 100, i, j;
+
+    if (hfile_list_plugins(plugins, &np) < 0)
+        return;
+
+    for (i = 0; i < np; i++) {
+        const char *sc_list[100];
+        int nschemes = 100;
+        if (hfile_list_schemes(plugins[i], sc_list, &nschemes) < 0)
+            return;
+
+        printf("    %s:\t", plugins[i]);
+        for (j = 0; j < nschemes; j++)
+            printf(" %s%c", sc_list[j], ",\n"[j+1==nschemes]);
+    }
+}
+
+static void usage(FILE *fp)
+{
+    /* Please improve the grouping */
+
+    fprintf(fp,
+"\n"
+"Program: samtools (Tools for alignments in the SAM format)\n"
+"Version: %s (using htslib %s)\n\n", samtools_version(), hts_version());
+    fprintf(fp,
+"Usage:   samtools <command> [options]\n"
+"\n"
+"Commands:\n"
+"  -- Indexing\n"
+"     dict           create a sequence dictionary file\n"
+"     faidx          index/extract FASTA\n"
+"     fqidx          index/extract FASTQ\n"
+"     index          index alignment\n"
+"\n"
+"  -- Editing\n"
+"     calmd          recalculate MD/NM tags and '=' bases\n"
+"     fixmate        fix mate information\n"
+"     reheader       replace BAM header\n"
+"     targetcut      cut fosmid regions (for fosmid pool only)\n"
+"     addreplacerg   adds or replaces RG tags\n"
+"     markdup        mark duplicates\n"
+"     ampliconclip   clip oligos from the end of reads\n"
+"\n"
+"  -- File operations\n"
+"     collate        shuffle and group alignments by name\n"
+"     cat            concatenate BAMs\n"
+"     consensus      produce a consensus Pileup/FASTA/FASTQ\n"
+"     merge          merge sorted alignments\n"
+"     mpileup        multi-way pileup\n"
+"     sort           sort alignment file\n"
+"     split          splits a file by read group\n"
+"     quickcheck     quickly check if SAM/BAM/CRAM file appears intact\n"
+"     fastq          converts a BAM to a FASTQ\n"
+"     fasta          converts a BAM to a FASTA\n"
+"     import         Converts FASTA or FASTQ files to SAM/BAM/CRAM\n"
+"     reference      Generates a reference from aligned data\n"
+"     reset          Reverts aligner changes in reads\n"
+"\n"
+"  -- Statistics\n"
+"     bedcov         read depth per BED region\n"
+"     coverage       alignment depth and percent coverage\n"
+"     depth          compute the depth\n"
+"     flagstat       simple stats\n"
+"     idxstats       BAM index stats\n"
+"     cram-size      list CRAM Content-ID and Data-Series sizes\n"
+"     phase          phase heterozygotes\n"
+"     stats          generate stats (former bamcheck)\n"
+"     ampliconstats  generate amplicon specific stats\n"
+"\n"
+"  -- Viewing\n"
+"     flags          explain BAM flags\n"
+"     head           header viewer\n"
+"     tview          text alignment viewer\n"
+"     view           SAM<->BAM<->CRAM conversion\n"
+"     depad          convert padded BAM to unpadded BAM\n"
+"     samples        list the samples in a set of SAM/BAM/CRAM files\n"
+"\n"
+"  -- Misc\n"
+"     help [cmd]     display this help message or help for [cmd]\n"
+"     version        detailed version information\n"
+"\n");
+}
+
+// This is a tricky one, but on Windows the filename wildcard expansion is done by
+// the application and not by the shell, as traditionally it never had a "shell".
+// Even now, DOS and Powershell do not do this expansion (but bash does).
+//
+// This means that Mingw/Msys implements code before main() that takes e.g. "*" and
+// expands it up to a list of matching filenames.  This in turn breaks things like
+// specifying "*" as a region (all the unmapped reads).  We take a hard line here -
+// filename expansion is the task of the shell, not our application!
+#ifdef _WIN32
+int _CRT_glob = 0;
+#endif
+
+int main(int argc, char *argv[])
+{
+#ifdef _WIN32
+    setmode(fileno(stdout), O_BINARY);
+    setmode(fileno(stdin),  O_BINARY);
+#endif
+    if (argc < 2) { usage(stderr); return 1; }
+
+    if (strcmp(argv[1], "help") == 0 || strcmp(argv[1], "--help") == 0) {
+        if (argc == 2) { usage(stdout); return 0; }
+
+        // Otherwise change "samtools help COMMAND [...]" to "samtools COMMAND";
+        // main_xyz() functions by convention display the subcommand's usage
+        // when invoked without any arguments.
+        argv++;
+        argc = 2;
+    }
+
+    int ret = 0;
+    if (strcmp(argv[1], "view") == 0)           ret = main_samview(argc-1, argv+1);
+    else if (strcmp(argv[1], "import") == 0)    ret = main_import(argc-1, argv+1);
+    else if (strcmp(argv[1], "mpileup") == 0)   ret = bam_mpileup(argc-1, argv+1);
+    else if (strcmp(argv[1], "merge") == 0)     ret = bam_merge(argc-1, argv+1);
+    else if (strcmp(argv[1], "sort") == 0)      ret = bam_sort(argc-1, argv+1);
+    else if (strcmp(argv[1], "index") == 0)     ret = bam_index(argc-1, argv+1);
+    else if (strcmp(argv[1], "idxstat") == 0 ||
+             strcmp(argv[1], "idxstats") == 0)  ret = bam_idxstats(argc-1, argv+1);
+    else if (strcmp(argv[1], "faidx") == 0)     ret = faidx_main(argc-1, argv+1);
+    else if (strcmp(argv[1], "fqidx") == 0)     ret = fqidx_main(argc-1, argv+1);
+    else if (strcmp(argv[1], "dict") == 0)      ret = dict_main(argc-1, argv+1);
+    else if (strcmp(argv[1], "head") == 0)      ret = main_head(argc-1, argv+1);
+    else if (strcmp(argv[1], "fixmate") == 0)   ret = bam_mating(argc-1, argv+1);
+    else if (strcmp(argv[1], "rmdup") == 0)     ret = bam_rmdup(argc-1, argv+1);
+    else if (strcmp(argv[1], "markdup") == 0)   ret = bam_markdup(argc-1, argv+1);
+    else if (strcmp(argv[1], "ampliconclip") == 0) ret = amplicon_clip_main(argc-1, argv+1);
+    else if (strcmp(argv[1], "flagstat") == 0 ||
+             strcmp(argv[1], "flagstats") == 0) ret = bam_flagstat(argc-1, argv+1);
+    else if (strcmp(argv[1], "calmd") == 0)     ret = bam_fillmd(argc-1, argv+1);
+    else if (strcmp(argv[1], "fillmd") == 0)    ret = bam_fillmd(argc-1, argv+1);
+    else if (strcmp(argv[1], "reheader") == 0)  ret = main_reheader(argc-1, argv+1);
+    else if (strcmp(argv[1], "cat") == 0)       ret = main_cat(argc-1, argv+1);
+    else if (strcmp(argv[1], "targetcut") == 0) ret = main_cut_target(argc-1, argv+1);
+    else if (strcmp(argv[1], "phase") == 0)     ret = main_phase(argc-1, argv+1);
+    else if (strcmp(argv[1], "depth") == 0)     ret = main_depth(argc-1, argv+1);
+    else if (strcmp(argv[1], "coverage") == 0)  ret = main_coverage(argc-1, argv+1);
+    else if (strcmp(argv[1], "bam2fq") == 0 ||
+             strcmp(argv[1], "fastq") == 0 ||
+             strcmp(argv[1], "fasta") == 0)     ret = main_bam2fq(argc-1, argv+1);
+    else if (strcmp(argv[1], "pad2unpad") == 0) ret = main_pad2unpad(argc-1, argv+1);
+    else if (strcmp(argv[1], "depad") == 0)     ret = main_pad2unpad(argc-1, argv+1);
+    else if (strcmp(argv[1], "bedcov") == 0)    ret = main_bedcov(argc-1, argv+1);
+    else if (strcmp(argv[1], "bamshuf") == 0)   ret = main_bamshuf(argc-1, argv+1);
+    else if (strcmp(argv[1], "collate") == 0)   ret = main_bamshuf(argc-1, argv+1);
+    else if (strcmp(argv[1], "stat") == 0 ||
+             strcmp(argv[1], "stats") == 0)     ret = main_stats(argc-1, argv+1);
+    else if (strcmp(argv[1], "flag") == 0 ||
+             strcmp(argv[1], "flags") == 0)     ret = main_flags(argc-1, argv+1);
+    else if (strcmp(argv[1], "split") == 0)     ret = main_split(argc-1, argv+1);
+    else if (strcmp(argv[1], "quickcheck") == 0)  ret = main_quickcheck(argc-1, argv+1);
+    else if (strcmp(argv[1], "addreplacerg") == 0) ret = main_addreplacerg(argc-1, argv+1);
+    else if (strcmp(argv[1], "pileup") == 0) {
+        fprintf(stderr, "[main] The `pileup' command has been removed. Please use `mpileup' instead.\n");
+        return 1;
+    }
+    else if (strcmp(argv[1], "tview") == 0)   ret = bam_tview_main(argc-1, argv+1);
+    else if (strcmp(argv[1], "ampliconstats") == 0)     ret = main_ampliconstats(argc-1, argv+1);
+    else if (strcmp(argv[1], "samples") == 0)     ret = main_samples(argc-1, argv+1);
+    else if (strcmp(argv[1], "consensus") == 0) ret = main_consensus(argc-1, argv+1);
+    else if (strcmp(argv[1], "reference") == 0) ret = main_reference(argc-1, argv+1);
+    else if (strcmp(argv[1], "cram-size") == 0) ret = main_cram_size(argc-1, argv+1);
+    else if (strcmp(argv[1], "version") == 0 || \
+             strcmp(argv[1], "--version") == 0)
+        long_version();
+    else if (strcmp(argv[1], "--version-only") == 0) {
+        printf("%s+htslib-%s\n", samtools_version(), hts_version());
+    }
+    else if (strcmp(argv[1], "reset") == 0) ret = main_reset(argc-1, argv+1);
+    else {
+        fprintf(stderr, "[main] unrecognized command '%s'\n", argv[1]);
+        return 1;
+    }
+    return ret;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bedidx.c

@@ -0,0 +1,637 @@
+/*  bedidx.c -- BED file indexing.
+
+    Copyright (C) 2011 Broad Institute.
+    Copyright (C) 2014, 2017-2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <zlib.h>
+#include "bedidx.h"
+
+#include "htslib/ksort.h"
+
+#include "htslib/kseq.h"
+KSTREAM_INIT(gzFile, gzread, 8192)
+
+static inline int lt_pair_pos(hts_pair_pos_t a, hts_pair_pos_t b) {
+    if (a.beg == b.beg) return a.end < b.end;
+    return a.beg < b.beg;
+}
+KSORT_INIT_STATIC(hts_pair_pos_t, hts_pair_pos_t, lt_pair_pos)
+
+/*! @typedef
+ * @abstract bed_reglist_t - value type of the BED hash table
+ * This structure encodes the list of intervals (ranges) for the regions provided via BED file or
+ * command line arguments.
+ * @field *a           pointer to the array of intervals.
+ * @field n            actual number of elements contained by a
+ * @field m            number of allocated elements to a (n <= m)
+ * @field *idx         index array for computing the minimum offset
+ */
+typedef struct {
+    int n, m;
+    hts_pair_pos_t *a;
+    int *idx;
+    int filter;
+} bed_reglist_t;
+
+#include "htslib/khash.h"
+KHASH_MAP_INIT_STR(reg, bed_reglist_t)
+
+typedef kh_reg_t reghash_t;
+
+#if 0
+// Debug function
+static void bed_print(void *reg_hash) {
+    reghash_t *h = (reghash_t *)reg_hash;
+    bed_reglist_t *p;
+    khint_t k;
+    int i;
+    const char *reg;
+
+    if (!h) {
+        printf("Hash table is empty!\n");
+        return;
+    }
+    for (k = kh_begin(h); k < kh_end(h); k++) {
+        if (kh_exist(h,k)) {
+            reg = kh_key(h,k);
+            printf("Region: '%s'\n", reg);
+            if ((p = &kh_val(h,k)) != NULL && p->n > 0) {
+                printf("Filter: %d\n", p->filter);
+                for (i=0; i<p->n; i++) {
+                    printf("\tinterval[%d]: %"PRIhts_pos"-%"PRIhts_pos"\n",
+                           i,p->a[i].beg,p->a[i].end);
+                }
+            } else {
+                printf("Region '%s' has no intervals!\n", reg);
+            }
+        }
+    }
+}
+#endif
+
+static int *bed_index_core(int n, hts_pair_pos_t *a)
+{
+    int i, j, l, *idx, *new_idx;
+    l = 0; idx = 0;
+    for (i = 0; i < n; ++i) {
+        hts_pos_t beg, end;
+        beg = a[i].beg >> LIDX_SHIFT; end = a[i].end >> LIDX_SHIFT;
+        if (l < end + 1) {
+            int old_l = l;
+            l = end + 1;
+            kroundup32(l);
+            new_idx = realloc(idx, l * sizeof(*idx));
+            if (!new_idx) {
+                free(idx);
+                return NULL;
+            }
+            idx = new_idx;
+
+            for (j = old_l; j < l; ++j)
+                idx[j] = -1;
+        }
+
+        for (j = beg; j < end+1; ++j)
+            if (idx[j] < 0)
+                idx[j] = i;
+    }
+    return idx;
+}
+
+static 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(hts_pair_pos_t, p->n, p->a);
+            p->idx = bed_index_core(p->n, p->a);
+        }
+    }
+}
+
+static int bed_minoff(const bed_reglist_t *p, hts_pos_t beg, hts_pos_t end) {
+    int i, min_off=0;
+
+    if (p && p->idx) {
+        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
+            hts_pos_t 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;
+        }
+    }
+
+    return min_off;
+}
+
+static int bed_overlap_core(const bed_reglist_t *p, hts_pos_t beg, hts_pos_t end)
+{
+    int i, min_off;
+    if (p->n == 0) return 0;
+    min_off = bed_minoff(p, beg, end);
+
+    for (i = min_off; i < p->n; ++i) {
+        if (p->a[i].beg >= end) break; // out of range; no need to proceed
+        if (p->a[i].end > beg && p->a[i].beg < end)
+            return 1; // find the overlap; return
+    }
+    return 0;
+}
+
+int bed_overlap(const void *_h, const char *chr, hts_pos_t beg, hts_pos_t 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);
+}
+
+/** @brief Trim a sorted interval list, inside a region hash table,
+ *   by removing completely contained intervals and merging adjacent or
+ *   overlapping intervals.
+ *  @param reg_hash    the region hash table with interval lists as values
+ */
+
+void bed_unify(void *reg_hash) {
+
+    int i, j, new_n;
+    reghash_t *h;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return;
+
+    h = (reghash_t *)reg_hash;
+
+    for (i = kh_begin(h); i < kh_end(h); i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || !(p->n))
+            continue;
+
+        for (new_n = 0, j = 1; j < p->n; j++) {
+            if (p->a[new_n].end < p->a[j].beg) {
+                p->a[++new_n] = p->a[j];
+            } else {
+                if (p->a[new_n].end < p->a[j].end)
+                    p->a[new_n].end = p->a[j].end;
+            }
+        }
+
+        p->n = ++new_n;
+    }
+}
+
+/* "BED" file reader, which actually reads two different formats.
+
+   BED files contain between three and nine fields per line, of which
+   only the first three (reference, start, end) are of interest to us.
+   BED counts positions from base 0, and the end is the base after the
+   region of interest.  While not properly documented in the specification,
+   it is also possible to have 'browser' and 'track' lines in BED files that
+   do not follow the standard format and should be ignored.  Examination
+   of the BED file reading code in
+   http://genome-source.cse.ucsc.edu/gitweb/?p=kent.git shows that BED
+   files can also have comment lines starting with '#', leading whitespace
+   is stripped, and that fields are separated by one or more consecutive
+   whitespace characters.
+
+   The alternative format was originally for reading positions in VCF
+   format.  This expects two columns, which indicate the reference and
+   a position.  The position corresponds to a single base, and unlike
+   BED counts from 1.
+
+   Which format is in use is determined based on whether one or two
+   numbers can be decoded on the line.  As this choice is made line-by-line
+   in this implementation, it is possible (but probably a bad idea) to mix
+   both formats in the same file.  If trying to read a VCF file by this
+   method, it would be important to ensure that the third column (ID) does
+   not contain any entries that start with a digit, to avoid the line
+   erroneously being parsed as a BED file entry.
+
+   The BED specification is at http://www.genome.ucsc.edu/FAQ/FAQformat.html
+   The VCF specification is at https://github.com/samtools/hts-specs
+ */
+
+void *bed_read(const char *fn)
+{
+    reghash_t *h = kh_init(reg);
+    gzFile fp;
+    kstream_t *ks = NULL;
+    int dret;
+    unsigned int line = 0, save_errno;
+    kstring_t str = { 0, 0, NULL };
+
+    if (NULL == h) return NULL;
+    // read the list
+    fp = strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
+    if (fp == 0) return 0;
+    ks = ks_init(fp);
+    if (NULL == ks) goto fail;  // In case ks_init ever gets error checking...
+    int ks_len;
+    while ((ks_len = ks_getuntil(ks, KS_SEP_LINE, &str, &dret)) >= 0) { // read a line
+        char *ref = str.s, *ref_end;
+        uint64_t beg = 0, end = 0;
+        int num = 0;
+        khint_t k;
+        bed_reglist_t *p;
+
+        if (ks_len == 0)
+            continue; // skip blank lines
+
+        line++;
+        while (*ref && isspace(*ref)) ref++;
+        if ('\0' == *ref) continue;  // Skip blank lines
+        if ('#'  == *ref) continue;  // Skip BED file comments
+        ref_end = ref;   // look for the end of the reference name
+        while (*ref_end && !isspace(*ref_end)) ref_end++;
+        if ('\0' != *ref_end) {
+            *ref_end = '\0';  // terminate ref and look for start, end
+            num = sscanf(ref_end + 1, "%"SCNu64" %"SCNu64, &beg, &end);
+        }
+        if (1 == num) {  // VCF-style format
+            end = beg--; // Counts from 1 instead of 0 for BED files
+        }
+        if (num < 1 || end < beg) {
+            // These two are special lines that can occur in BED files.
+            // Check for them here instead of earlier in case someone really
+            // has called their reference "browser" or "track".
+            if (0 == strcmp(ref, "browser")) continue;
+            if (0 == strcmp(ref, "track")) continue;
+            if (num < 1) {
+                fprintf(stderr,
+                        "[bed_read] Parse error reading \"%s\" at line %u\n",
+                        fn, line);
+            } else {
+                fprintf(stderr,
+                        "[bed_read] Parse error reading \"%s\" at line %u : "
+                        "end (%"PRIu64") must not be less "
+                        "than start (%"PRIu64")\n",
+                        fn, line, end, beg);
+            }
+            errno = 0; // Prevent caller from printing misleading error messages
+            goto fail;
+        }
+
+        // Put reg in the hash table if not already there
+        k = kh_get(reg, h, ref);
+        if (k == kh_end(h)) { // absent from the hash table
+            int ret;
+            char *s = strdup(ref);
+            if (NULL == s) goto fail;
+            k = kh_put(reg, h, s, &ret);
+            if (-1 == ret) {
+                free(s);
+                goto fail;
+            }
+            memset(&kh_val(h, k), 0, sizeof(bed_reglist_t));
+        }
+        p = &kh_val(h, k);
+
+        // Add begin,end to the list
+        if (p->n == p->m) {
+            p->m = p->m ? p->m<<1 : 4;
+            hts_pair_pos_t *new_a = realloc(p->a, p->m * sizeof(p->a[0]));
+            if (NULL == new_a) goto fail;
+            p->a = new_a;
+        }
+        p->a[p->n].beg = beg;
+        p->a[p->n++].end = end;
+    }
+    // FIXME: Need to check for errors in ks_getuntil.  At the moment it
+    // doesn't look like it can return one.  Possibly use gzgets instead?
+
+    if (gzclose(fp) != Z_OK) {
+        fp = NULL;
+        goto fail;
+    }
+    ks_destroy(ks);
+    free(str.s);
+    bed_index(h);
+    //bed_unify(h);
+    return h;
+ fail:
+    save_errno = errno;
+    if (ks) ks_destroy(ks);
+    if (fp) gzclose(fp);
+    free(str.s);
+    bed_destroy(h);
+    errno = save_errno;
+    return NULL;
+}
+
+void bed_destroy(void *_h)
+{
+    reghash_t *h;
+    khint_t k;
+
+    if (!_h)
+        return;
+
+    h = (reghash_t*)_h;
+    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);
+}
+
+static void *bed_insert(void *reg_hash, char *reg, hts_pos_t beg, hts_pos_t end) {
+
+    reghash_t *h;
+    khint_t k;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+
+    // Put reg in the hash table if not already there
+    k = kh_get(reg, h, reg); //looks strange, but only the second reg is the actual region name.
+    if (k == kh_end(h)) { // absent from the hash table
+        int ret;
+        char *s = strdup(reg);
+        if (NULL == s) goto fail;
+        k = kh_put(reg, h, s, &ret);
+        if (-1 == ret) {
+            free(s);
+            goto fail;
+        }
+        memset(&kh_val(h, k), 0, sizeof(bed_reglist_t));
+    }
+    p = &kh_val(h, k);
+
+    // Add beg and end to the list
+    if (p->n == p->m) {
+        p->m = p->m ? p->m<<1 : 4;
+        hts_pair_pos_t *new_a = realloc(p->a, p->m * sizeof(p->a[0]));
+        if (NULL == new_a) goto fail;
+        p->a = new_a;
+    }
+    p->a[p->n].beg = beg;
+    p->a[p->n++].end = end;
+
+fail:
+    return h;
+}
+
+/* @brief Filter a region hash table (coming from the BED file) by another
+ *  region hash table (coming from CLI), so that only intervals contained in
+ *  both hash tables are kept.
+ * @param reg_hash    the target region hash table
+ * @param tmp_hash    the filter region hash table
+ * @return            pointer to the filtered hash table
+ */
+
+static void *bed_filter(void *reg_hash, void *tmp_hash) {
+
+    reghash_t *h;
+    reghash_t *t;
+    bed_reglist_t *p, *q;
+    khint_t l, k;
+    hts_pair_pos_t *new_a;
+    int i, j, new_n, min_off;
+    const char *reg;
+    hts_pos_t beg, end;
+
+    h = (reghash_t *)reg_hash;
+    t = (reghash_t *)tmp_hash;
+    if (!h)
+        return NULL;
+    if (!t)
+        return h;
+
+    for (l = kh_begin(t); l < kh_end(t); l++) {
+        if (!kh_exist(t,l) || !(q = &kh_val(t,l)) || !(q->n))
+            continue;
+
+        reg = kh_key(t,l);
+        k = kh_get(reg, h, reg); //looks strange, but only the second reg is a proper argument.
+        if (k == kh_end(h) || !(p = &kh_val(h, k)) || !(p->n))
+            continue;
+
+        new_a = calloc(q->n + p->n, sizeof(new_a[0]));
+        if (!new_a)
+            return NULL;
+        new_n = 0;
+
+        for (i = 0; i < q->n; i++) {
+            beg = q->a[i].beg;
+            end = q->a[i].end;
+
+            min_off = bed_minoff(p, beg, end);
+            for (j = min_off; j < p->n; ++j) {
+                if (p->a[j].beg >= end) break; // out of range; no need to proceed
+                if (p->a[j].end > beg && p->a[j].beg < end) {
+                    new_a[new_n].beg = MAX(p->a[j].beg, beg);
+                    new_a[new_n++].end = MIN(p->a[j].end, end);
+                }
+            }
+        }
+
+        if (new_n > 0) {
+            free(p->a);
+            p->a = new_a;
+            p->n = new_n;
+            p->m = new_n;
+            p->filter = FILTERED;
+        } else {
+            free(new_a);
+            p->filter = ALL;
+        }
+    }
+
+    return h;
+}
+
+void *bed_hash_regions(void *reg_hash, char **regs, int first, int last, int *op) {
+
+    reghash_t *h = (reghash_t *)reg_hash;
+    reghash_t *t = NULL;
+
+    int i;
+    char reg[1024];
+    const char *q;
+    int beg, end;
+
+    if (h) {
+        t = kh_init(reg);
+        if (!t) {
+            fprintf(stderr, "Error when creating the temporary region hash table!\n");
+            return NULL;
+        }
+    } else {
+        h = kh_init(reg);
+        if (!h) {
+            fprintf(stderr, "Error when creating the region hash table!\n");
+            return NULL;
+        }
+        *op = 1;
+    }
+
+    for (i=first; i<last; i++) {
+
+        // Note, ideally we would call sam_parse_region here, but it's complicated by not
+        // having the sam header known and the likelihood of the bed file containing data for other
+        // references too which we currently just ignore.
+        //
+        // TO DO...
+        q = hts_parse_reg(regs[i], &beg, &end);
+        if (q) {
+            if ((int)(q - regs[i] + 1) > 1024) {
+                fprintf(stderr, "Region name '%s' is too long (bigger than %d).\n", regs[i], 1024);
+                continue;
+            }
+            strncpy(reg, regs[i], q - regs[i]);
+            reg[q - regs[i]] = 0;
+        } else {
+            // not parsable as a region, but possibly a sequence named "foo:a"
+            if (strlen(regs[i]) + 1 > 1024) {
+                fprintf(stderr, "Region name '%s' is too long (bigger than %d).\n", regs[i], 1024);
+                continue;
+            }
+            strcpy(reg, regs[i]);
+            beg = 0; end = INT_MAX;
+        }
+
+        //if op==1 insert reg to the bed hash table
+        if (*op && !(bed_insert(h, reg, beg, end))) {
+            fprintf(stderr, "Error when inserting region='%s' in the bed hash table at address=%p!\n", regs[i], h);
+        }
+        //if op==0, first insert the regions in the temporary hash table,
+        //then filter the bed hash table using it
+        if (!(*op) && !(bed_insert(t, reg, beg, end))) {
+            fprintf(stderr, "Error when inserting region='%s' in the temporary hash table at address=%p!\n", regs[i], t);
+        }
+    }
+
+    if (!(*op)) {
+        bed_index(t);
+        bed_unify(t);
+        h = bed_filter(h, t);
+        bed_destroy(t);
+    }
+
+    if (h) {
+        bed_index(h);
+        bed_unify(h);
+    }
+
+    return h;
+}
+
+const char* bed_get(void *reg_hash, int i, int filter) {
+
+    reghash_t *h;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+    if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+        return NULL;
+
+    return kh_key(h, i);
+}
+
+/**
+ * Create a region list from a the region hash table
+ * @param  reg_hash  The region hash table
+ * @param  filter    0 - allow all regions, 1 - allow only selected regions
+ * @param  n_reg     Pointer to the returned region number
+ * @return           The regions list as a hts_reglist_t
+ */
+
+hts_reglist_t *bed_reglist(void *reg_hash, int filter, int *n_reg) {
+
+    reghash_t *h;
+    bed_reglist_t *p;
+    khint_t i;
+    hts_reglist_t *reglist = NULL;
+    int count = 0;
+    int j;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+
+    for (i = kh_begin(h); i < kh_end(h); i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+            continue;
+        count++;
+    }
+    if (!count)
+        return NULL;
+
+    reglist = (hts_reglist_t *)calloc(count, sizeof(hts_reglist_t));
+    if (!reglist)
+        return NULL;
+
+    *n_reg = count;
+    count = 0;
+
+    for (i = kh_begin(h); i < kh_end(h) && count < *n_reg; i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+            continue;
+
+        reglist[count].reg = kh_key(h,i);
+        reglist[count].intervals = (hts_pair32_t *)calloc(p->n, sizeof(hts_pair32_t));
+        if(!(reglist[count].intervals)) {
+            hts_reglist_free(reglist, count);
+            return NULL;
+        }
+        reglist[count].count = p->n;
+        reglist[count].max_end = 0;
+
+        for (j = 0; j < p->n; j++) {
+            reglist[count].intervals[j].beg = p->a[j].beg;
+            reglist[count].intervals[j].end = p->a[j].end;
+
+            if (reglist[count].intervals[j].end > reglist[count].max_end)
+                reglist[count].max_end = reglist[count].intervals[j].end;
+        }
+        count++;
+    }
+
+    return reglist;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bedidx.c.pysam.c

@@ -0,0 +1,639 @@
+#include "samtools.pysam.h"
+
+/*  bedidx.c -- BED file indexing.
+
+    Copyright (C) 2011 Broad Institute.
+    Copyright (C) 2014, 2017-2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <zlib.h>
+#include "bedidx.h"
+
+#include "htslib/ksort.h"
+
+#include "htslib/kseq.h"
+KSTREAM_INIT(gzFile, gzread, 8192)
+
+static inline int lt_pair_pos(hts_pair_pos_t a, hts_pair_pos_t b) {
+    if (a.beg == b.beg) return a.end < b.end;
+    return a.beg < b.beg;
+}
+KSORT_INIT_STATIC(hts_pair_pos_t, hts_pair_pos_t, lt_pair_pos)
+
+/*! @typedef
+ * @abstract bed_reglist_t - value type of the BED hash table
+ * This structure encodes the list of intervals (ranges) for the regions provided via BED file or
+ * command line arguments.
+ * @field *a           pointer to the array of intervals.
+ * @field n            actual number of elements contained by a
+ * @field m            number of allocated elements to a (n <= m)
+ * @field *idx         index array for computing the minimum offset
+ */
+typedef struct {
+    int n, m;
+    hts_pair_pos_t *a;
+    int *idx;
+    int filter;
+} bed_reglist_t;
+
+#include "htslib/khash.h"
+KHASH_MAP_INIT_STR(reg, bed_reglist_t)
+
+typedef kh_reg_t reghash_t;
+
+#if 0
+// Debug function
+static void bed_print(void *reg_hash) {
+    reghash_t *h = (reghash_t *)reg_hash;
+    bed_reglist_t *p;
+    khint_t k;
+    int i;
+    const char *reg;
+
+    if (!h) {
+        fprintf(samtools_stdout, "Hash table is empty!\n");
+        return;
+    }
+    for (k = kh_begin(h); k < kh_end(h); k++) {
+        if (kh_exist(h,k)) {
+            reg = kh_key(h,k);
+            fprintf(samtools_stdout, "Region: '%s'\n", reg);
+            if ((p = &kh_val(h,k)) != NULL && p->n > 0) {
+                fprintf(samtools_stdout, "Filter: %d\n", p->filter);
+                for (i=0; i<p->n; i++) {
+                    fprintf(samtools_stdout, "\tinterval[%d]: %"PRIhts_pos"-%"PRIhts_pos"\n",
+                           i,p->a[i].beg,p->a[i].end);
+                }
+            } else {
+                fprintf(samtools_stdout, "Region '%s' has no intervals!\n", reg);
+            }
+        }
+    }
+}
+#endif
+
+static int *bed_index_core(int n, hts_pair_pos_t *a)
+{
+    int i, j, l, *idx, *new_idx;
+    l = 0; idx = 0;
+    for (i = 0; i < n; ++i) {
+        hts_pos_t beg, end;
+        beg = a[i].beg >> LIDX_SHIFT; end = a[i].end >> LIDX_SHIFT;
+        if (l < end + 1) {
+            int old_l = l;
+            l = end + 1;
+            kroundup32(l);
+            new_idx = realloc(idx, l * sizeof(*idx));
+            if (!new_idx) {
+                free(idx);
+                return NULL;
+            }
+            idx = new_idx;
+
+            for (j = old_l; j < l; ++j)
+                idx[j] = -1;
+        }
+
+        for (j = beg; j < end+1; ++j)
+            if (idx[j] < 0)
+                idx[j] = i;
+    }
+    return idx;
+}
+
+static 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(hts_pair_pos_t, p->n, p->a);
+            p->idx = bed_index_core(p->n, p->a);
+        }
+    }
+}
+
+static int bed_minoff(const bed_reglist_t *p, hts_pos_t beg, hts_pos_t end) {
+    int i, min_off=0;
+
+    if (p && p->idx) {
+        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
+            hts_pos_t 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;
+        }
+    }
+
+    return min_off;
+}
+
+static int bed_overlap_core(const bed_reglist_t *p, hts_pos_t beg, hts_pos_t end)
+{
+    int i, min_off;
+    if (p->n == 0) return 0;
+    min_off = bed_minoff(p, beg, end);
+
+    for (i = min_off; i < p->n; ++i) {
+        if (p->a[i].beg >= end) break; // out of range; no need to proceed
+        if (p->a[i].end > beg && p->a[i].beg < end)
+            return 1; // find the overlap; return
+    }
+    return 0;
+}
+
+int bed_overlap(const void *_h, const char *chr, hts_pos_t beg, hts_pos_t 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);
+}
+
+/** @brief Trim a sorted interval list, inside a region hash table,
+ *   by removing completely contained intervals and merging adjacent or
+ *   overlapping intervals.
+ *  @param reg_hash    the region hash table with interval lists as values
+ */
+
+void bed_unify(void *reg_hash) {
+
+    int i, j, new_n;
+    reghash_t *h;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return;
+
+    h = (reghash_t *)reg_hash;
+
+    for (i = kh_begin(h); i < kh_end(h); i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || !(p->n))
+            continue;
+
+        for (new_n = 0, j = 1; j < p->n; j++) {
+            if (p->a[new_n].end < p->a[j].beg) {
+                p->a[++new_n] = p->a[j];
+            } else {
+                if (p->a[new_n].end < p->a[j].end)
+                    p->a[new_n].end = p->a[j].end;
+            }
+        }
+
+        p->n = ++new_n;
+    }
+}
+
+/* "BED" file reader, which actually reads two different formats.
+
+   BED files contain between three and nine fields per line, of which
+   only the first three (reference, start, end) are of interest to us.
+   BED counts positions from base 0, and the end is the base after the
+   region of interest.  While not properly documented in the specification,
+   it is also possible to have 'browser' and 'track' lines in BED files that
+   do not follow the standard format and should be ignored.  Examination
+   of the BED file reading code in
+   http://genome-source.cse.ucsc.edu/gitweb/?p=kent.git shows that BED
+   files can also have comment lines starting with '#', leading whitespace
+   is stripped, and that fields are separated by one or more consecutive
+   whitespace characters.
+
+   The alternative format was originally for reading positions in VCF
+   format.  This expects two columns, which indicate the reference and
+   a position.  The position corresponds to a single base, and unlike
+   BED counts from 1.
+
+   Which format is in use is determined based on whether one or two
+   numbers can be decoded on the line.  As this choice is made line-by-line
+   in this implementation, it is possible (but probably a bad idea) to mix
+   both formats in the same file.  If trying to read a VCF file by this
+   method, it would be important to ensure that the third column (ID) does
+   not contain any entries that start with a digit, to avoid the line
+   erroneously being parsed as a BED file entry.
+
+   The BED specification is at http://www.genome.ucsc.edu/FAQ/FAQformat.html
+   The VCF specification is at https://github.com/samtools/hts-specs
+ */
+
+void *bed_read(const char *fn)
+{
+    reghash_t *h = kh_init(reg);
+    gzFile fp;
+    kstream_t *ks = NULL;
+    int dret;
+    unsigned int line = 0, save_errno;
+    kstring_t str = { 0, 0, NULL };
+
+    if (NULL == h) return NULL;
+    // read the list
+    fp = strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
+    if (fp == 0) return 0;
+    ks = ks_init(fp);
+    if (NULL == ks) goto fail;  // In case ks_init ever gets error checking...
+    int ks_len;
+    while ((ks_len = ks_getuntil(ks, KS_SEP_LINE, &str, &dret)) >= 0) { // read a line
+        char *ref = str.s, *ref_end;
+        uint64_t beg = 0, end = 0;
+        int num = 0;
+        khint_t k;
+        bed_reglist_t *p;
+
+        if (ks_len == 0)
+            continue; // skip blank lines
+
+        line++;
+        while (*ref && isspace(*ref)) ref++;
+        if ('\0' == *ref) continue;  // Skip blank lines
+        if ('#'  == *ref) continue;  // Skip BED file comments
+        ref_end = ref;   // look for the end of the reference name
+        while (*ref_end && !isspace(*ref_end)) ref_end++;
+        if ('\0' != *ref_end) {
+            *ref_end = '\0';  // terminate ref and look for start, end
+            num = sscanf(ref_end + 1, "%"SCNu64" %"SCNu64, &beg, &end);
+        }
+        if (1 == num) {  // VCF-style format
+            end = beg--; // Counts from 1 instead of 0 for BED files
+        }
+        if (num < 1 || end < beg) {
+            // These two are special lines that can occur in BED files.
+            // Check for them here instead of earlier in case someone really
+            // has called their reference "browser" or "track".
+            if (0 == strcmp(ref, "browser")) continue;
+            if (0 == strcmp(ref, "track")) continue;
+            if (num < 1) {
+                fprintf(samtools_stderr,
+                        "[bed_read] Parse error reading \"%s\" at line %u\n",
+                        fn, line);
+            } else {
+                fprintf(samtools_stderr,
+                        "[bed_read] Parse error reading \"%s\" at line %u : "
+                        "end (%"PRIu64") must not be less "
+                        "than start (%"PRIu64")\n",
+                        fn, line, end, beg);
+            }
+            errno = 0; // Prevent caller from printing misleading error messages
+            goto fail;
+        }
+
+        // Put reg in the hash table if not already there
+        k = kh_get(reg, h, ref);
+        if (k == kh_end(h)) { // absent from the hash table
+            int ret;
+            char *s = strdup(ref);
+            if (NULL == s) goto fail;
+            k = kh_put(reg, h, s, &ret);
+            if (-1 == ret) {
+                free(s);
+                goto fail;
+            }
+            memset(&kh_val(h, k), 0, sizeof(bed_reglist_t));
+        }
+        p = &kh_val(h, k);
+
+        // Add begin,end to the list
+        if (p->n == p->m) {
+            p->m = p->m ? p->m<<1 : 4;
+            hts_pair_pos_t *new_a = realloc(p->a, p->m * sizeof(p->a[0]));
+            if (NULL == new_a) goto fail;
+            p->a = new_a;
+        }
+        p->a[p->n].beg = beg;
+        p->a[p->n++].end = end;
+    }
+    // FIXME: Need to check for errors in ks_getuntil.  At the moment it
+    // doesn't look like it can return one.  Possibly use gzgets instead?
+
+    if (gzclose(fp) != Z_OK) {
+        fp = NULL;
+        goto fail;
+    }
+    ks_destroy(ks);
+    free(str.s);
+    bed_index(h);
+    //bed_unify(h);
+    return h;
+ fail:
+    save_errno = errno;
+    if (ks) ks_destroy(ks);
+    if (fp) gzclose(fp);
+    free(str.s);
+    bed_destroy(h);
+    errno = save_errno;
+    return NULL;
+}
+
+void bed_destroy(void *_h)
+{
+    reghash_t *h;
+    khint_t k;
+
+    if (!_h)
+        return;
+
+    h = (reghash_t*)_h;
+    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);
+}
+
+static void *bed_insert(void *reg_hash, char *reg, hts_pos_t beg, hts_pos_t end) {
+
+    reghash_t *h;
+    khint_t k;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+
+    // Put reg in the hash table if not already there
+    k = kh_get(reg, h, reg); //looks strange, but only the second reg is the actual region name.
+    if (k == kh_end(h)) { // absent from the hash table
+        int ret;
+        char *s = strdup(reg);
+        if (NULL == s) goto fail;
+        k = kh_put(reg, h, s, &ret);
+        if (-1 == ret) {
+            free(s);
+            goto fail;
+        }
+        memset(&kh_val(h, k), 0, sizeof(bed_reglist_t));
+    }
+    p = &kh_val(h, k);
+
+    // Add beg and end to the list
+    if (p->n == p->m) {
+        p->m = p->m ? p->m<<1 : 4;
+        hts_pair_pos_t *new_a = realloc(p->a, p->m * sizeof(p->a[0]));
+        if (NULL == new_a) goto fail;
+        p->a = new_a;
+    }
+    p->a[p->n].beg = beg;
+    p->a[p->n++].end = end;
+
+fail:
+    return h;
+}
+
+/* @brief Filter a region hash table (coming from the BED file) by another
+ *  region hash table (coming from CLI), so that only intervals contained in
+ *  both hash tables are kept.
+ * @param reg_hash    the target region hash table
+ * @param tmp_hash    the filter region hash table
+ * @return            pointer to the filtered hash table
+ */
+
+static void *bed_filter(void *reg_hash, void *tmp_hash) {
+
+    reghash_t *h;
+    reghash_t *t;
+    bed_reglist_t *p, *q;
+    khint_t l, k;
+    hts_pair_pos_t *new_a;
+    int i, j, new_n, min_off;
+    const char *reg;
+    hts_pos_t beg, end;
+
+    h = (reghash_t *)reg_hash;
+    t = (reghash_t *)tmp_hash;
+    if (!h)
+        return NULL;
+    if (!t)
+        return h;
+
+    for (l = kh_begin(t); l < kh_end(t); l++) {
+        if (!kh_exist(t,l) || !(q = &kh_val(t,l)) || !(q->n))
+            continue;
+
+        reg = kh_key(t,l);
+        k = kh_get(reg, h, reg); //looks strange, but only the second reg is a proper argument.
+        if (k == kh_end(h) || !(p = &kh_val(h, k)) || !(p->n))
+            continue;
+
+        new_a = calloc(q->n + p->n, sizeof(new_a[0]));
+        if (!new_a)
+            return NULL;
+        new_n = 0;
+
+        for (i = 0; i < q->n; i++) {
+            beg = q->a[i].beg;
+            end = q->a[i].end;
+
+            min_off = bed_minoff(p, beg, end);
+            for (j = min_off; j < p->n; ++j) {
+                if (p->a[j].beg >= end) break; // out of range; no need to proceed
+                if (p->a[j].end > beg && p->a[j].beg < end) {
+                    new_a[new_n].beg = MAX(p->a[j].beg, beg);
+                    new_a[new_n++].end = MIN(p->a[j].end, end);
+                }
+            }
+        }
+
+        if (new_n > 0) {
+            free(p->a);
+            p->a = new_a;
+            p->n = new_n;
+            p->m = new_n;
+            p->filter = FILTERED;
+        } else {
+            free(new_a);
+            p->filter = ALL;
+        }
+    }
+
+    return h;
+}
+
+void *bed_hash_regions(void *reg_hash, char **regs, int first, int last, int *op) {
+
+    reghash_t *h = (reghash_t *)reg_hash;
+    reghash_t *t = NULL;
+
+    int i;
+    char reg[1024];
+    const char *q;
+    int beg, end;
+
+    if (h) {
+        t = kh_init(reg);
+        if (!t) {
+            fprintf(samtools_stderr, "Error when creating the temporary region hash table!\n");
+            return NULL;
+        }
+    } else {
+        h = kh_init(reg);
+        if (!h) {
+            fprintf(samtools_stderr, "Error when creating the region hash table!\n");
+            return NULL;
+        }
+        *op = 1;
+    }
+
+    for (i=first; i<last; i++) {
+
+        // Note, ideally we would call sam_parse_region here, but it's complicated by not
+        // having the sam header known and the likelihood of the bed file containing data for other
+        // references too which we currently just ignore.
+        //
+        // TO DO...
+        q = hts_parse_reg(regs[i], &beg, &end);
+        if (q) {
+            if ((int)(q - regs[i] + 1) > 1024) {
+                fprintf(samtools_stderr, "Region name '%s' is too long (bigger than %d).\n", regs[i], 1024);
+                continue;
+            }
+            strncpy(reg, regs[i], q - regs[i]);
+            reg[q - regs[i]] = 0;
+        } else {
+            // not parsable as a region, but possibly a sequence named "foo:a"
+            if (strlen(regs[i]) + 1 > 1024) {
+                fprintf(samtools_stderr, "Region name '%s' is too long (bigger than %d).\n", regs[i], 1024);
+                continue;
+            }
+            strcpy(reg, regs[i]);
+            beg = 0; end = INT_MAX;
+        }
+
+        //if op==1 insert reg to the bed hash table
+        if (*op && !(bed_insert(h, reg, beg, end))) {
+            fprintf(samtools_stderr, "Error when inserting region='%s' in the bed hash table at address=%p!\n", regs[i], h);
+        }
+        //if op==0, first insert the regions in the temporary hash table,
+        //then filter the bed hash table using it
+        if (!(*op) && !(bed_insert(t, reg, beg, end))) {
+            fprintf(samtools_stderr, "Error when inserting region='%s' in the temporary hash table at address=%p!\n", regs[i], t);
+        }
+    }
+
+    if (!(*op)) {
+        bed_index(t);
+        bed_unify(t);
+        h = bed_filter(h, t);
+        bed_destroy(t);
+    }
+
+    if (h) {
+        bed_index(h);
+        bed_unify(h);
+    }
+
+    return h;
+}
+
+const char* bed_get(void *reg_hash, int i, int filter) {
+
+    reghash_t *h;
+    bed_reglist_t *p;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+    if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+        return NULL;
+
+    return kh_key(h, i);
+}
+
+/**
+ * Create a region list from a the region hash table
+ * @param  reg_hash  The region hash table
+ * @param  filter    0 - allow all regions, 1 - allow only selected regions
+ * @param  n_reg     Pointer to the returned region number
+ * @return           The regions list as a hts_reglist_t
+ */
+
+hts_reglist_t *bed_reglist(void *reg_hash, int filter, int *n_reg) {
+
+    reghash_t *h;
+    bed_reglist_t *p;
+    khint_t i;
+    hts_reglist_t *reglist = NULL;
+    int count = 0;
+    int j;
+
+    if (!reg_hash)
+        return NULL;
+
+    h = (reghash_t *)reg_hash;
+
+    for (i = kh_begin(h); i < kh_end(h); i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+            continue;
+        count++;
+    }
+    if (!count)
+        return NULL;
+
+    reglist = (hts_reglist_t *)calloc(count, sizeof(hts_reglist_t));
+    if (!reglist)
+        return NULL;
+
+    *n_reg = count;
+    count = 0;
+
+    for (i = kh_begin(h); i < kh_end(h) && count < *n_reg; i++) {
+        if (!kh_exist(h,i) || !(p = &kh_val(h,i)) || (p->filter < filter))
+            continue;
+
+        reglist[count].reg = kh_key(h,i);
+        reglist[count].intervals = (hts_pair32_t *)calloc(p->n, sizeof(hts_pair32_t));
+        if(!(reglist[count].intervals)) {
+            hts_reglist_free(reglist, count);
+            return NULL;
+        }
+        reglist[count].count = p->n;
+        reglist[count].max_end = 0;
+
+        for (j = 0; j < p->n; j++) {
+            reglist[count].intervals[j].beg = p->a[j].beg;
+            reglist[count].intervals[j].end = p->a[j].end;
+
+            if (reglist[count].intervals[j].end > reglist[count].max_end)
+                reglist[count].max_end = reglist[count].intervals[j].end;
+        }
+        count++;
+    }
+
+    return reglist;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/bedidx.h

@@ -0,0 +1,45 @@
+/*  bedidx.h -- BED file indexing header file.
+
+    Copyright (C) 2017 Genome Research Ltd.
+
+    Author: Valeriu Ohan <vo2@sanger.ac.uk>
+
+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.  */
+
+#ifndef BEDIDX_H
+#define BEDIDX_H
+
+#include "htslib/hts.h"
+
+#define LIDX_SHIFT 13
+#define ALL 0
+#define FILTERED 1
+
+#define MIN(A,B) ( ( (A) < (B) ) ? (A) : (B) )
+#define MAX(A,B) ( ( (A) > (B) ) ? (A) : (B) )
+
+void *bed_read(const char *fn);
+void bed_destroy(void *_h);
+int bed_overlap(const void *_h, const char *chr, hts_pos_t beg, hts_pos_t end);
+void *bed_hash_regions(void *reg_hash, char **regs, int first, int last, int *op);
+const char* bed_get(void *reg_hash, int index, int filter);
+hts_reglist_t *bed_reglist(void *reg_hash, int filter, int *count_regs);
+void bed_unify(void *_h);
+
+#endif

falcon/lib/python3.10/site-packages/pysam/include/samtools/consensus_pileup.h

@@ -0,0 +1,102 @@
+/*  consensus_pileup.h -- Pileup orientated data per consensus column
+
+    Copyright (C) 2013-2016, 2020-2022 Genome Research Ltd.
+
+    Author: James Bonfied <jkb@sanger.ac.uk>
+
+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 notices 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.  */
+
+#include <htslib/sam.h>
+
+typedef struct pileup {
+    // commonly used things together, to fit in a cache line (64 bytes)
+    struct pileup *next;  // A link list, for active seqs
+    void *cd;             // General purpose per-seq client-data
+    int  eof;             // True if this sequence has finished
+    int  qual;            // Current qual (for active seq only)
+    char start;           // True if this is a new sequence
+    char base;            // Current base (for active seq only) in ASCII
+    char ref_skip;        // True if the cause of eof or start is cigar N
+    char padding;         // True if the base was added due to another seq
+    int  base4;           // Base in 4-bit notation (0-15)
+    hts_pos_t pos;        // Current unpadded position in seq
+    int  nth;             // nth base at unpadded position 'pos'
+    int  b_is_rev;        // 0 => fwd, 1 => rev
+    int  seq_offset;      // Current base position in s->seq[] array.
+
+    unsigned char *b_qual;// cached bam_qual
+    unsigned char *b_seq; // cached bam_seq
+
+    // --- 64 bytes
+    struct pileup *eofn;  // p->eof set, next eof member
+    struct pileup *eofl;  // last non-eof that points to p with p->eof
+
+    uint32_t *b_cigar;    // cached bam_cigar
+
+    int  cigar_ind;       // Current location in s->alignment cigar str
+    int  cigar_op;        // Current cigar operation
+    int  cigar_len;       // Remaining length of this cigar op
+
+    int  first_del;       // Used when first base is a deletion
+
+    bam1_t b;             // Bam entry associated with struct
+} pileup_t;
+
+/*
+ * The pileup loop executes and calls callbacks to perform the work.
+ *
+ * seq_fetch returns the next sequence.  Return 0 from this indicates no
+ *   more data.
+ *
+ * seq_init is called, if non-NULL, when a sequence is added to the pileup,
+ * seq_free likewise, if non-NULL, is called when a sequence is removed
+ *   from the pileup.
+ * These two functions are akin to the constructor and destructors added
+ * to mpileup.
+ *
+ * seq_column is the primary work horse which is executed for each
+ *   reference position, and for each inserted base per ref pos.
+ *
+ * If we were to invert this from a loop generating callbacks to a polled
+ * style interface like mpileup, then the seq_column bit would be dropped
+ * and replaced by the returned pileup and associated parameters.
+ */
+int pileup_loop(samFile *fp,
+                sam_hdr_t *h,
+                int (*seq_fetch)(void *client_data,
+                                 samFile *fp,
+                                 sam_hdr_t *h,
+                                 bam1_t *b),
+                int (*seq_init)(void *client_data,
+                                samFile *fp,
+                                sam_hdr_t *h,
+                                pileup_t *p),
+                int (*seq_column)(void *client_data,
+                                  samFile *fp,
+                                  sam_hdr_t *h,
+                                  pileup_t *p,
+                                  int depth,
+                                  hts_pos_t pos,
+                                  int nth,
+                                  int is_insert),
+                void (*seq_free)(void *client_data,
+                                 samFile *fp,
+                                 sam_hdr_t *h,
+                                 pileup_t *p),
+                void *client_data);

falcon/lib/python3.10/site-packages/pysam/include/samtools/cram_size.c

@@ -0,0 +1,665 @@
+/*  cram_size.c -- produces summary of the size of each cram data-series
+
+    Copyright (C) 2023 Genome Research Ltd.
+
+    Author: James Bonfield <jkb@sanger.ac.uk>
+
+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.  */
+
+// TODO: add range query.  Eg the ability to look at size for "*" only
+// (unmapped), or in a specific region such as a centromere.
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+
+#include "htslib/bgzf.h"
+#include "htslib/sam.h"
+#include "htslib/cram.h"
+#include "htslib/kstring.h"
+#include "htslib/khash.h"
+#include "samtools.h"
+#include "sam_opts.h"
+#include "htslib/hfile.h"
+
+/*----------------------------------------------------------------------
+ * Compression method handling
+ */
+
+// A numeric version of the cram_method_details struct.
+// We expand the myriad of struct field combinations into a single
+// enumerated type so we can index and accumulate statistics for
+// purposes of reporting.
+//
+// These expanded numeric values have no definition within CRAM itself
+// and never occur within the file format.
+enum comp_expanded {
+    //----
+    // Copies from htslib cram_block_method enum
+    COMP_RAW    = CRAM_COMP_RAW,
+    COMP_GZIP   = CRAM_COMP_GZIP,
+    COMP_BZIP2  = CRAM_COMP_BZIP2,
+    COMP_LZMA   = CRAM_COMP_LZMA,
+    COMP_RANS8  = CRAM_COMP_RANS4x8,
+    COMP_RANS16 = CRAM_COMP_RANSNx16,
+    COMP_ARITH  = CRAM_COMP_ARITH,
+    COMP_FQZ    = CRAM_COMP_FQZ,
+    COMP_TOK3   = CRAM_COMP_TOK3,
+
+    //----
+    // Localised variants.
+
+    // Gzip
+    COMP_GZIP_1,
+    COMP_GZIP_9,
+
+    // Bzip2
+    COMP_BZIP2_1,
+    COMP_BZIP2_2,
+    COMP_BZIP2_3,
+    COMP_BZIP2_4,
+    COMP_BZIP2_5,
+    COMP_BZIP2_6,
+    COMP_BZIP2_7,
+    COMP_BZIP2_8,
+    COMP_BZIP2_9,
+
+    // rans 4x8
+    COMP_RANS4x8_O0,
+    COMP_RANS4x8_O1,
+
+    // rans Nx16.  Note order here is to enable selection via bit-fields
+    // bit 0: O0/O1
+    // bit 1: RLE
+    // bit 2: PACK
+    // bit 3: 32x16
+    COMP_RANS4x16_O0,
+    COMP_RANS4x16_O1,
+    COMP_RANS4x16_O0R,   // +RLE
+    COMP_RANS4x16_O1R,
+    COMP_RANS4x16_O0P,   // +PACK
+    COMP_RANS4x16_O1P,
+    COMP_RANS4x16_O0PR,  // +PACK+RLE
+    COMP_RANS4x16_O1PR,
+    COMP_RANS32x16_O0,   // SIMD variants
+    COMP_RANS32x16_O1,
+    COMP_RANS32x16_O0R,  // +RLE
+    COMP_RANS32x16_O1R,
+    COMP_RANS32x16_O0P,  // +PACK
+    COMP_RANS32x16_O1P,
+    COMP_RANS32x16_O0PR, // +PACK+RLE
+    COMP_RANS32x16_O1PR,
+    COMP_RANSNx16_STRIPE,
+    COMP_RANSNx16_CAT,
+
+    // Arith
+    COMP_ARITH_O0,
+    COMP_ARITH_O1,
+    COMP_ARITH_O0R,   // +RLE
+    COMP_ARITH_O1R,
+    COMP_ARITH_O0P,   // +PACK
+    COMP_ARITH_O1P,
+    COMP_ARITH_O0PR,  // +PACK+RLE
+    COMP_ARITH_O1PR,
+    COMP_ARITH_STRIPE,
+    COMP_ARITH_CAT,   // no entropy encoder
+    COMP_ARITH_EXT,   // external entropy encode
+
+    // Nake tokeniser
+    COMP_TOK3_RANS,
+    COMP_TOK3_ARITH,
+
+    // To mark maximum size
+    COMP_MAX,
+};
+
+static enum comp_expanded comp_method2expanded(cram_method_details *cm) {
+    switch (cm->method) {
+    case CRAM_COMP_GZIP:
+        switch (cm->level) {
+        case 1:  return COMP_GZIP_1;
+        case 9:  return COMP_GZIP_9;
+        default: return COMP_GZIP;
+        }
+        break;
+
+    case CRAM_COMP_BZIP2:
+        if (cm->level >= 1 && cm->level <= 9)
+            return COMP_BZIP2_1 + cm->level-1;
+        else
+            return COMP_BZIP2;
+        break;
+
+    case CRAM_COMP_RANS4x8:
+        return cm->order ? COMP_RANS4x8_O1 : COMP_RANS4x8_O0;
+
+    case CRAM_COMP_RANSNx16: {
+        // 8 4x16, 8 32x16 and 2 stripe/cat
+        if (cm->stripe) return COMP_RANSNx16_STRIPE;
+        if (cm->cat)    return COMP_RANSNx16_CAT;
+        int c = COMP_RANS4x16_O0;
+        c += 1*cm->order;
+        c += 2*cm->rle;
+        c += 4*cm->pack;
+        c += 8*(cm->Nway==32);
+        return c;
+    }
+
+    case CRAM_COMP_ARITH: {
+        // 8 4x16, 8 32x16 and 2 stripe/cat
+        if (cm->stripe) return COMP_ARITH_STRIPE;
+        if (cm->cat)    return COMP_ARITH_CAT;
+        if (cm->ext)    return COMP_ARITH_EXT;
+        int c = COMP_ARITH_O0;
+        c += 1*cm->order;
+        c += 2*cm->rle;
+        c += 4*cm->pack;
+        return c;
+    }
+
+    case CRAM_COMP_TOK3:
+        return cm->level < 10
+            ? COMP_TOK3_RANS
+            : COMP_TOK3_ARITH;
+
+    default:
+        // Any unspecialised method
+        return (enum comp_expanded)cm->method;
+    }
+}
+
+// Short form of cram_block_method_int type
+static char comp_method2char[COMP_MAX] =
+    ".gblr0afn"           // standard CRAM methods
+    "_G"                  // gzip
+    "bbbbbbbbB"           // bzip2
+    "rR"                  // rans4x8
+    "010101014545454582"  // ransNx16
+    "aAaAaAaAaaa"         // arith
+    "nN";                 // tok3
+
+// Long form of cram_block_method_int type
+static char *comp_method2str[COMP_MAX] = {
+    // Standard CRAM methods
+    "raw", "gzip", "bzip2", "lzma", "r4x8", "rNx16",
+    "arith", "fqzcomp", "tok3",
+
+    // custom gzip
+    "gzip-min", "gzip-max",
+
+    // custom bzip2
+    "bzip2-1", "bzip2-2", "bzip2-3", "bzip2-4", "bzip2-5",
+    "bzip2-6", "bzip2-7", "bzip2-8", "bzip2-9",
+
+    // rANS 4x8
+    "r4x8-o0", "r4x8-o1",
+
+    // rANS 4x16
+    "r4x16-o0",   "r4x16-o1",
+
+    "r4x16-o0R",  "r4x16-o1R",
+    "r4x16-o0P",  "r4x16-o1P",
+    "r4x16-o0PR", "r4x16-o1PR",
+    "r32x16-o0",  "r32x16-o1",
+    "r32x16-o0R", "r32x16-o1R",
+    "r32x16-o0P", "r32x16-o1P",
+    "r32x16-o0PR","r32x16-o1PR",
+    "rNx16-xo0",  "rNx16-cat",
+
+    // Arith
+    "arith-o0",   "arith-o1",
+    "arith-o0R",  "arith-o1R",
+    "arith-o0P",  "arith-o1P",
+    "arith-o0PR", "arith-o1PR",
+    "arith-stripe", "arith-cat", "arith-ext",
+
+    // Name tokeniser
+    "tok3-rans", "tok3-arith",
+};
+
+/*----------------------------------------------------------------------
+ * Manipulation and sorting of Block Content-ID arrays and hashes
+ */
+
+typedef struct {
+    int64_t csize[COMP_MAX];
+    int64_t usize[COMP_MAX];
+} cusize_t;
+
+static int64_t total_csize(cusize_t *cu) {
+    int i;
+    int64_t tot = 0;
+    for (i = 0; i < COMP_MAX; i++)
+        tot += cu->csize[i];
+    return tot;
+}
+
+static int64_t total_usize(cusize_t *cu) {
+    int i;
+    int64_t tot = 0;
+    for (i = 0; i < COMP_MAX; i++)
+        tot += cu->usize[i];
+    return tot;
+}
+
+// cusize_t array and sorting by compressed size
+static cusize_t *sort_cusize_global; // avoids a messy extra data type
+static int sort_cusize_compar(const void *i1, const void *i2) {
+    int64_t n = sort_cusize_global->csize[*(const int *)i2] -
+                sort_cusize_global->csize[*(const int *)i1];
+    return n > 0 ? 1 : (n < 0 ? -1 : *(const int *)i1 - *(const int *)i2);
+}
+
+// Sort a cusize array by size of used method.
+// Returns cu->csize[comp] indices in descending size, as static mem
+static int *sort_cusize(cusize_t *cu) {
+    static int idx[COMP_MAX];
+    int i;
+    for (i = 0; i < COMP_MAX; i++)
+        idx[i] = i;
+    sort_cusize_global = cu;
+    qsort(idx, COMP_MAX, sizeof(*idx), sort_cusize_compar);
+
+    return idx;
+}
+
+// Hash table of cusize_t and sorting by key (content-id)
+KHASH_MAP_INIT_INT(cu, cusize_t)
+
+/* Sort by hash key. Global due to rubbish qsort API, but it's simple. */
+static khash_t(cu) *global_cu_hash = NULL;
+static int cu_compar(const void *i1, const void *i2) {
+    return kh_key(global_cu_hash, *(const int *)i1) -
+           kh_key(global_cu_hash, *(const int *)i2);
+}
+
+/*----------------------------------------------------------------------
+ * Main cram_size reporting and aggregation
+ */
+static off_t report_size(FILE *outfp, int verbose, int ref_seq_blk,
+                         khash_t(cu) *cu_size, cram_cid2ds_t *cid2ds) {
+    if (!cu_size || !cid2ds)
+        return -1;
+
+    khiter_t k;
+    off_t tot_size = 0;
+
+    fprintf(outfp, "#   Content_ID  Uncomp.size    Comp.size   Ratio Method%.*s  Data_series\n", verbose ? 4 : 0, "    ");
+    int *sorted_blocks = malloc(kh_end(cu_size)*sizeof(int));
+    if (!sorted_blocks)
+        return -1;
+    int nblocks = 0;
+    for (k = kh_begin(cu_size); k != kh_end(cu_size); k++) {
+        if (!kh_exist(cu_size, k))
+            continue;
+        sorted_blocks[nblocks++] = k;
+    }
+    global_cu_hash = cu_size;
+    qsort(sorted_blocks, nblocks, sizeof(int), cu_compar);
+
+    int i;
+    for (i = 0; i < nblocks; i++) {
+        k = sorted_blocks[i];
+
+        if (verbose) {
+            // FULL output
+            int *comp_idx = sort_cusize(&kh_value(cu_size, k));
+            int first_line = 1, c, j;
+            for (c = 0; c < COMP_MAX; c++) {
+                int comp = comp_idx[c];
+                if (!kh_value(cu_size, k).csize[comp] && c)
+                    break;
+
+                if (!first_line)
+                    fprintf(outfp, "\n");
+                first_line = 0;
+
+                if ((int)kh_key(cu_size, k) < 0)
+                    fprintf(outfp, "BLOCK %8s", "CORE");
+                else
+                    fprintf(outfp, "BLOCK %8d", kh_key(cu_size, k));
+
+                fprintf(outfp, " %12"PRId64" %12"PRId64,
+                        kh_value(cu_size, k).usize[comp],
+                        kh_value(cu_size, k).csize[comp]);
+                double f = (100.0*(kh_value(cu_size, k).csize[comp]+.0001)) /
+                    (kh_value(cu_size, k).usize[comp]+.0001);
+                if (f > 999)
+                    fprintf(outfp, "   >999%% %-11s", comp_method2str[comp]);
+                else
+                    fprintf(outfp, " %6.2f%% %-11s",f, comp_method2str[comp]);
+
+                int n, *dsa = cram_cid2ds_query(cid2ds, kh_key(cu_size, k), &n);
+                for (j = 0; j < n; j++) {
+                    int d = dsa[j];
+                    if (d > 65535)
+                        fprintf(outfp, " %c%c%c", d>>16, (d>>8)&0xff, d&0xff);
+                    else
+                        fprintf(outfp, " %c%c", (d>>8)&0xff, d&0xff);
+                }
+            }
+        } else {
+            // aggregate by compression type.
+            int64_t csize = total_csize(&kh_value(cu_size, k));
+            int64_t usize = total_usize(&kh_value(cu_size, k));
+            int *comp_idx = sort_cusize(&kh_value(cu_size, k));
+
+            char cstr[COMP_MAX+1] = {0};
+            int cidx = 0, c;
+            for (c = 0; c < COMP_MAX; c++) {
+                if (!kh_value(cu_size, k).csize[comp_idx[c]])
+                    break;
+                cstr[cidx++] = comp_method2char[comp_idx[c]];
+            }
+            if (!*cstr) *cstr = '.';
+
+            if ((int)kh_key(cu_size, k) < 0)
+                fprintf(outfp, "BLOCK %8s", "CORE");
+            else
+                fprintf(outfp, "BLOCK %8d", kh_key(cu_size, k));
+            fprintf(outfp, " %12"PRId64" %12"PRId64, usize, csize);
+            double f = 100*(csize+.0001)/(usize+.0001);
+            if (f > 999)
+                fprintf(outfp, "   >999%% %-7s", cstr);
+            else
+                fprintf(outfp, " %6.2f%% %-7s", f, cstr);
+
+            int n, j, *dsa = cram_cid2ds_query(cid2ds, kh_key(cu_size, k), &n);
+            for (j = 0; j < n; j++) {
+                int d = dsa[j];
+                if (d > 65535)
+                    fprintf(outfp, " %c%c%c", d>>16, (d>>8)&0xff, d&0xff);
+                else
+                    fprintf(outfp, " %c%c", (d>>8)&0xff, d&0xff);
+            }
+        }
+
+        if ((int)kh_key(cu_size, k) >= 0 &&
+            (int)kh_key(cu_size, k) == ref_seq_blk) {
+            fprintf(outfp, " embedded_ref");
+        }
+        fprintf(outfp, "\n");
+
+        tot_size += total_csize(&kh_value(cu_size, k));
+    }
+
+    free(sorted_blocks);
+
+    return tot_size;
+}
+
+/* Main processing loop */
+static int cram_size(hFILE *hf_in, samFile *in, sam_hdr_t *h, FILE *outfp,
+                     int verbose, int encodings) {
+    cram_fd *in_c;
+    cram_container *c = NULL;
+    cram_block *blk = NULL;
+    cram_block_slice_hdr *shdr = NULL;
+    khiter_t k;
+    int ret;
+    cram_cid2ds_t *cid2ds = NULL;
+    khash_t(cu) *cu_size = kh_init(cu);
+    int ref_seq_blk_used = -1;
+    int64_t nseqs = 0, nbases = 0, ncont = 0, nslice = 0;
+
+    if (!in->is_cram) {
+        print_error("cram_size", "Input is not a CRAM file");
+        goto err;
+    }
+    in_c = in->fp.cram; // low level htslib abuse?
+    while ((c = cram_read_container(in_c))) {
+        if (cram_container_is_empty(in_c)) {
+            cram_block *blk;
+            // Container compression header
+            if (!(blk = cram_read_block(in_c)))
+                goto err;
+            cram_free_block(blk);
+            cram_free_container(c);
+            c = NULL; blk = NULL;
+            continue;
+        }
+
+        nseqs  += cram_container_get_num_records(c);
+        nbases += cram_container_get_num_bases(c);
+
+        // Container compression header
+        int32_t num_slices;
+        if (!(blk = cram_read_block(in_c)))
+            goto err;
+
+        // Decode compression header...
+        cram_block_compression_hdr *chdr;
+        chdr = cram_decode_compression_header(in_c, blk);
+
+        if (encodings) {
+            kstring_t ks = KS_INITIALIZE;
+            if (cram_describe_encodings(chdr, &ks) < 0)
+                goto err;
+
+            fprintf(outfp, "Container encodings\n%s\n", ks_str(&ks));
+
+            ks_free(&ks);
+        }
+
+        cid2ds = cram_update_cid2ds_map(chdr, cid2ds);
+
+        cram_free_block(blk);
+        blk = NULL;
+
+        cram_free_compression_header(chdr);
+
+        // Container num_blocks can be invalid, due to a bug.
+        // Instead we iterate in slice context instead.
+        (void)cram_container_get_landmarks(c, &num_slices);
+        ncont++;
+        nslice += num_slices;
+
+        int i, j;
+        for (i = 0; i < num_slices; i++) {
+            // Slice header
+            if (!(blk = cram_read_block(in_c)))
+                goto err;
+            if (!(shdr = cram_decode_slice_header(in_c, blk)))
+                goto err;
+            cram_free_block(blk);
+            blk = NULL;
+
+            int ref_seq_blk = cram_slice_hdr_get_embed_ref_id(shdr);
+            int num_blocks = cram_slice_hdr_get_num_blocks(shdr);
+
+            // Embedded reference.  Check it's consistent (if used this is
+            // an almost guaranteed certainty, so we take the easy route).
+            if (ref_seq_blk >= 0) {
+                if (ref_seq_blk_used == -1)
+                    ref_seq_blk_used = ref_seq_blk;
+                else if (ref_seq_blk_used != ref_seq_blk)
+                    fprintf(stderr, "Embedded reference is not consistently using the same Content-Id.\n"
+                            "Reported figures for reference will be invalid.\n");
+            }
+
+            // Slice data blocks
+            for (j = 0; j < num_blocks; j++) {
+                // read and discard, unless it's the ref-ID block
+                if (!(blk = cram_read_block(in_c)))
+                    goto err;
+
+                int32_t csize = cram_block_get_comp_size(blk);
+                int32_t usize = cram_block_get_uncomp_size(blk);
+                int cid = cram_block_get_content_id(blk);
+                enum cram_block_method method = cram_block_get_method(blk);
+
+                // Expand comp to the internal sub-formats, eg
+                // rANS order-0/1, PACK+RLE, etc.
+                cram_method_details *cm;
+                cm = cram_expand_method(cram_block_get_data(blk),
+                                        cram_block_get_comp_size(blk),
+                                        method);
+                if (!cm)
+                    goto err;
+                enum comp_expanded comp
+                    = comp_method2expanded(cm);
+                free(cm);
+
+                k = kh_put(cu, cu_size, cid, &ret);
+                if (ret < 0)
+                    goto err;
+                if (ret == 0) {
+                    kh_value(cu_size, k).csize[comp] += csize;
+                    kh_value(cu_size, k).usize[comp] += usize;
+                } else {
+                    memset(&kh_value(cu_size, k), 0, sizeof(cusize_t));
+                    kh_value(cu_size, k).csize[comp]  = csize;
+                    kh_value(cu_size, k).usize[comp]  = usize;
+                }
+
+                cram_free_block(blk);
+                blk = NULL;
+            }
+            cram_free_slice_header(shdr);
+            shdr = NULL;
+        }
+
+        cram_free_container(c);
+        c = NULL;
+    }
+
+    off_t tot_size = report_size(outfp, verbose, ref_seq_blk_used,
+                                 cu_size, cid2ds);
+    if (tot_size < 0)
+        goto err;
+
+    kh_destroy(cu, cu_size);
+    cram_cid2ds_free(cid2ds);
+
+    off_t end = htell(hf_in);
+
+    fprintf(outfp, "\n");
+    fprintf(outfp, "Number of containers  %18"PRId64"\n", ncont);
+    fprintf(outfp, "Number of slices      %18"PRId64"\n", nslice);
+    fprintf(outfp, "Number of sequences   %18"PRId64"\n", nseqs);
+    fprintf(outfp, "Number of bases       %18"PRId64"\n", nbases);
+    fprintf(outfp, "Total file size       %18"PRId64"\n", (int64_t) end);
+    fprintf(outfp, "Format overhead size  %18"PRId64"\n", (int64_t) (end - tot_size));
+
+    return 0;
+
+ err:
+    // Report anyway so we can get stats on partial files, but be
+    // sure to error too.
+    report_size(outfp, verbose, ref_seq_blk_used, cu_size, cid2ds);
+
+    print_error("cram_size", "Failed in decoding CRAM file");
+    if (blk)
+        cram_free_block(blk);
+    if (shdr)
+        cram_free_slice_header(shdr);
+    if (c)
+        cram_free_container(c);
+    if (cid2ds)
+        cram_cid2ds_free(cid2ds);
+
+    return -1;
+}
+
+/* main() for cram_size */
+int main_cram_size(int argc, char *argv[]) {
+    int c, usage = 0, verbose = 0, encodings = 0;
+    sam_hdr_t *h = 0;
+    hFILE *hf_in = NULL;
+    samFile *in = NULL;
+    sam_global_args ga;
+    FILE *outfp = stdout;
+
+    static const struct option lopts[] = {
+        {"output", required_argument, NULL, 'o'},
+        {"verbose",  no_argument, NULL, 'v'},
+        {"encodings", no_argument, NULL, 'e'},
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', '-', '-'),
+        { NULL, 0, NULL, 0 }
+    };
+
+    sam_global_args_init(&ga);
+
+    while ((c = getopt_long(argc, argv, "vo:e", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'o':
+            if (!(outfp = fopen(optarg, "w"))) {
+                perror(optarg);
+                goto err;
+            }
+            break;
+
+        case 'v':
+            verbose++;
+            break;
+
+        case 'e':
+            encodings++;
+            break;
+
+        default:
+            if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?': usage=1; break;
+        }
+    }
+
+    if ((optind == argc && isatty(0)) || usage) {
+        printf("Usage: samtools cram_size [-ve] [-o out.size] [in.cram]\n");
+        return 0;
+    }
+
+    char *fn = optind < argc ? argv[optind] : "-";
+
+    // We want access to in->fp.cram->fp, but this is an opaque struct so we
+    // can't get that.  However we opened with hopen and then reopen as
+    // CRAM with hts_hopen, which will swallow the initial hFILE and take
+    // owenership of it.  Hence we now know in->fp.cram->fp.
+    if (!(hf_in = hopen(fn, "r"))) {
+        print_error_errno("cram_size", "failed to open file '%s'", fn);
+        return 1;
+    }
+    if (!(in = hts_hopen(hf_in, fn, "r"))) {
+        print_error_errno("cram_size", "failed to open file '%s'", fn);
+        goto err;
+    }
+
+    if (!(h = sam_hdr_read(in)))
+        goto err;
+
+    int ret = cram_size(hf_in, in, h, outfp, verbose, encodings);
+    sam_hdr_destroy(h);
+    sam_close(in);
+    if (outfp != stdout)
+        fclose(outfp);
+
+    return ret ? 1 : 0;
+
+ err:
+    if (in)
+        sam_close(in);
+    if (h)
+        sam_hdr_destroy(h);
+
+    return 1;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/cram_size.c.pysam.c

@@ -0,0 +1,667 @@
+#include "samtools.pysam.h"
+
+/*  cram_size.c -- produces summary of the size of each cram data-series
+
+    Copyright (C) 2023 Genome Research Ltd.
+
+    Author: James Bonfield <jkb@sanger.ac.uk>
+
+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.  */
+
+// TODO: add range query.  Eg the ability to look at size for "*" only
+// (unmapped), or in a specific region such as a centromere.
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <strings.h>
+
+#include "htslib/bgzf.h"
+#include "htslib/sam.h"
+#include "htslib/cram.h"
+#include "htslib/kstring.h"
+#include "htslib/khash.h"
+#include "samtools.h"
+#include "sam_opts.h"
+#include "htslib/hfile.h"
+
+/*----------------------------------------------------------------------
+ * Compression method handling
+ */
+
+// A numeric version of the cram_method_details struct.
+// We expand the myriad of struct field combinations into a single
+// enumerated type so we can index and accumulate statistics for
+// purposes of reporting.
+//
+// These expanded numeric values have no definition within CRAM itself
+// and never occur within the file format.
+enum comp_expanded {
+    //----
+    // Copies from htslib cram_block_method enum
+    COMP_RAW    = CRAM_COMP_RAW,
+    COMP_GZIP   = CRAM_COMP_GZIP,
+    COMP_BZIP2  = CRAM_COMP_BZIP2,
+    COMP_LZMA   = CRAM_COMP_LZMA,
+    COMP_RANS8  = CRAM_COMP_RANS4x8,
+    COMP_RANS16 = CRAM_COMP_RANSNx16,
+    COMP_ARITH  = CRAM_COMP_ARITH,
+    COMP_FQZ    = CRAM_COMP_FQZ,
+    COMP_TOK3   = CRAM_COMP_TOK3,
+
+    //----
+    // Localised variants.
+
+    // Gzip
+    COMP_GZIP_1,
+    COMP_GZIP_9,
+
+    // Bzip2
+    COMP_BZIP2_1,
+    COMP_BZIP2_2,
+    COMP_BZIP2_3,
+    COMP_BZIP2_4,
+    COMP_BZIP2_5,
+    COMP_BZIP2_6,
+    COMP_BZIP2_7,
+    COMP_BZIP2_8,
+    COMP_BZIP2_9,
+
+    // rans 4x8
+    COMP_RANS4x8_O0,
+    COMP_RANS4x8_O1,
+
+    // rans Nx16.  Note order here is to enable selection via bit-fields
+    // bit 0: O0/O1
+    // bit 1: RLE
+    // bit 2: PACK
+    // bit 3: 32x16
+    COMP_RANS4x16_O0,
+    COMP_RANS4x16_O1,
+    COMP_RANS4x16_O0R,   // +RLE
+    COMP_RANS4x16_O1R,
+    COMP_RANS4x16_O0P,   // +PACK
+    COMP_RANS4x16_O1P,
+    COMP_RANS4x16_O0PR,  // +PACK+RLE
+    COMP_RANS4x16_O1PR,
+    COMP_RANS32x16_O0,   // SIMD variants
+    COMP_RANS32x16_O1,
+    COMP_RANS32x16_O0R,  // +RLE
+    COMP_RANS32x16_O1R,
+    COMP_RANS32x16_O0P,  // +PACK
+    COMP_RANS32x16_O1P,
+    COMP_RANS32x16_O0PR, // +PACK+RLE
+    COMP_RANS32x16_O1PR,
+    COMP_RANSNx16_STRIPE,
+    COMP_RANSNx16_CAT,
+
+    // Arith
+    COMP_ARITH_O0,
+    COMP_ARITH_O1,
+    COMP_ARITH_O0R,   // +RLE
+    COMP_ARITH_O1R,
+    COMP_ARITH_O0P,   // +PACK
+    COMP_ARITH_O1P,
+    COMP_ARITH_O0PR,  // +PACK+RLE
+    COMP_ARITH_O1PR,
+    COMP_ARITH_STRIPE,
+    COMP_ARITH_CAT,   // no entropy encoder
+    COMP_ARITH_EXT,   // external entropy encode
+
+    // Nake tokeniser
+    COMP_TOK3_RANS,
+    COMP_TOK3_ARITH,
+
+    // To mark maximum size
+    COMP_MAX,
+};
+
+static enum comp_expanded comp_method2expanded(cram_method_details *cm) {
+    switch (cm->method) {
+    case CRAM_COMP_GZIP:
+        switch (cm->level) {
+        case 1:  return COMP_GZIP_1;
+        case 9:  return COMP_GZIP_9;
+        default: return COMP_GZIP;
+        }
+        break;
+
+    case CRAM_COMP_BZIP2:
+        if (cm->level >= 1 && cm->level <= 9)
+            return COMP_BZIP2_1 + cm->level-1;
+        else
+            return COMP_BZIP2;
+        break;
+
+    case CRAM_COMP_RANS4x8:
+        return cm->order ? COMP_RANS4x8_O1 : COMP_RANS4x8_O0;
+
+    case CRAM_COMP_RANSNx16: {
+        // 8 4x16, 8 32x16 and 2 stripe/cat
+        if (cm->stripe) return COMP_RANSNx16_STRIPE;
+        if (cm->cat)    return COMP_RANSNx16_CAT;
+        int c = COMP_RANS4x16_O0;
+        c += 1*cm->order;
+        c += 2*cm->rle;
+        c += 4*cm->pack;
+        c += 8*(cm->Nway==32);
+        return c;
+    }
+
+    case CRAM_COMP_ARITH: {
+        // 8 4x16, 8 32x16 and 2 stripe/cat
+        if (cm->stripe) return COMP_ARITH_STRIPE;
+        if (cm->cat)    return COMP_ARITH_CAT;
+        if (cm->ext)    return COMP_ARITH_EXT;
+        int c = COMP_ARITH_O0;
+        c += 1*cm->order;
+        c += 2*cm->rle;
+        c += 4*cm->pack;
+        return c;
+    }
+
+    case CRAM_COMP_TOK3:
+        return cm->level < 10
+            ? COMP_TOK3_RANS
+            : COMP_TOK3_ARITH;
+
+    default:
+        // Any unspecialised method
+        return (enum comp_expanded)cm->method;
+    }
+}
+
+// Short form of cram_block_method_int type
+static char comp_method2char[COMP_MAX] =
+    ".gblr0afn"           // standard CRAM methods
+    "_G"                  // gzip
+    "bbbbbbbbB"           // bzip2
+    "rR"                  // rans4x8
+    "010101014545454582"  // ransNx16
+    "aAaAaAaAaaa"         // arith
+    "nN";                 // tok3
+
+// Long form of cram_block_method_int type
+static char *comp_method2str[COMP_MAX] = {
+    // Standard CRAM methods
+    "raw", "gzip", "bzip2", "lzma", "r4x8", "rNx16",
+    "arith", "fqzcomp", "tok3",
+
+    // custom gzip
+    "gzip-min", "gzip-max",
+
+    // custom bzip2
+    "bzip2-1", "bzip2-2", "bzip2-3", "bzip2-4", "bzip2-5",
+    "bzip2-6", "bzip2-7", "bzip2-8", "bzip2-9",
+
+    // rANS 4x8
+    "r4x8-o0", "r4x8-o1",
+
+    // rANS 4x16
+    "r4x16-o0",   "r4x16-o1",
+
+    "r4x16-o0R",  "r4x16-o1R",
+    "r4x16-o0P",  "r4x16-o1P",
+    "r4x16-o0PR", "r4x16-o1PR",
+    "r32x16-o0",  "r32x16-o1",
+    "r32x16-o0R", "r32x16-o1R",
+    "r32x16-o0P", "r32x16-o1P",
+    "r32x16-o0PR","r32x16-o1PR",
+    "rNx16-xo0",  "rNx16-cat",
+
+    // Arith
+    "arith-o0",   "arith-o1",
+    "arith-o0R",  "arith-o1R",
+    "arith-o0P",  "arith-o1P",
+    "arith-o0PR", "arith-o1PR",
+    "arith-stripe", "arith-cat", "arith-ext",
+
+    // Name tokeniser
+    "tok3-rans", "tok3-arith",
+};
+
+/*----------------------------------------------------------------------
+ * Manipulation and sorting of Block Content-ID arrays and hashes
+ */
+
+typedef struct {
+    int64_t csize[COMP_MAX];
+    int64_t usize[COMP_MAX];
+} cusize_t;
+
+static int64_t total_csize(cusize_t *cu) {
+    int i;
+    int64_t tot = 0;
+    for (i = 0; i < COMP_MAX; i++)
+        tot += cu->csize[i];
+    return tot;
+}
+
+static int64_t total_usize(cusize_t *cu) {
+    int i;
+    int64_t tot = 0;
+    for (i = 0; i < COMP_MAX; i++)
+        tot += cu->usize[i];
+    return tot;
+}
+
+// cusize_t array and sorting by compressed size
+static cusize_t *sort_cusize_global; // avoids a messy extra data type
+static int sort_cusize_compar(const void *i1, const void *i2) {
+    int64_t n = sort_cusize_global->csize[*(const int *)i2] -
+                sort_cusize_global->csize[*(const int *)i1];
+    return n > 0 ? 1 : (n < 0 ? -1 : *(const int *)i1 - *(const int *)i2);
+}
+
+// Sort a cusize array by size of used method.
+// Returns cu->csize[comp] indices in descending size, as static mem
+static int *sort_cusize(cusize_t *cu) {
+    static int idx[COMP_MAX];
+    int i;
+    for (i = 0; i < COMP_MAX; i++)
+        idx[i] = i;
+    sort_cusize_global = cu;
+    qsort(idx, COMP_MAX, sizeof(*idx), sort_cusize_compar);
+
+    return idx;
+}
+
+// Hash table of cusize_t and sorting by key (content-id)
+KHASH_MAP_INIT_INT(cu, cusize_t)
+
+/* Sort by hash key. Global due to rubbish qsort API, but it's simple. */
+static khash_t(cu) *global_cu_hash = NULL;
+static int cu_compar(const void *i1, const void *i2) {
+    return kh_key(global_cu_hash, *(const int *)i1) -
+           kh_key(global_cu_hash, *(const int *)i2);
+}
+
+/*----------------------------------------------------------------------
+ * Main cram_size reporting and aggregation
+ */
+static off_t report_size(FILE *outfp, int verbose, int ref_seq_blk,
+                         khash_t(cu) *cu_size, cram_cid2ds_t *cid2ds) {
+    if (!cu_size || !cid2ds)
+        return -1;
+
+    khiter_t k;
+    off_t tot_size = 0;
+
+    fprintf(outfp, "#   Content_ID  Uncomp.size    Comp.size   Ratio Method%.*s  Data_series\n", verbose ? 4 : 0, "    ");
+    int *sorted_blocks = malloc(kh_end(cu_size)*sizeof(int));
+    if (!sorted_blocks)
+        return -1;
+    int nblocks = 0;
+    for (k = kh_begin(cu_size); k != kh_end(cu_size); k++) {
+        if (!kh_exist(cu_size, k))
+            continue;
+        sorted_blocks[nblocks++] = k;
+    }
+    global_cu_hash = cu_size;
+    qsort(sorted_blocks, nblocks, sizeof(int), cu_compar);
+
+    int i;
+    for (i = 0; i < nblocks; i++) {
+        k = sorted_blocks[i];
+
+        if (verbose) {
+            // FULL output
+            int *comp_idx = sort_cusize(&kh_value(cu_size, k));
+            int first_line = 1, c, j;
+            for (c = 0; c < COMP_MAX; c++) {
+                int comp = comp_idx[c];
+                if (!kh_value(cu_size, k).csize[comp] && c)
+                    break;
+
+                if (!first_line)
+                    fprintf(outfp, "\n");
+                first_line = 0;
+
+                if ((int)kh_key(cu_size, k) < 0)
+                    fprintf(outfp, "BLOCK %8s", "CORE");
+                else
+                    fprintf(outfp, "BLOCK %8d", kh_key(cu_size, k));
+
+                fprintf(outfp, " %12"PRId64" %12"PRId64,
+                        kh_value(cu_size, k).usize[comp],
+                        kh_value(cu_size, k).csize[comp]);
+                double f = (100.0*(kh_value(cu_size, k).csize[comp]+.0001)) /
+                    (kh_value(cu_size, k).usize[comp]+.0001);
+                if (f > 999)
+                    fprintf(outfp, "   >999%% %-11s", comp_method2str[comp]);
+                else
+                    fprintf(outfp, " %6.2f%% %-11s",f, comp_method2str[comp]);
+
+                int n, *dsa = cram_cid2ds_query(cid2ds, kh_key(cu_size, k), &n);
+                for (j = 0; j < n; j++) {
+                    int d = dsa[j];
+                    if (d > 65535)
+                        fprintf(outfp, " %c%c%c", d>>16, (d>>8)&0xff, d&0xff);
+                    else
+                        fprintf(outfp, " %c%c", (d>>8)&0xff, d&0xff);
+                }
+            }
+        } else {
+            // aggregate by compression type.
+            int64_t csize = total_csize(&kh_value(cu_size, k));
+            int64_t usize = total_usize(&kh_value(cu_size, k));
+            int *comp_idx = sort_cusize(&kh_value(cu_size, k));
+
+            char cstr[COMP_MAX+1] = {0};
+            int cidx = 0, c;
+            for (c = 0; c < COMP_MAX; c++) {
+                if (!kh_value(cu_size, k).csize[comp_idx[c]])
+                    break;
+                cstr[cidx++] = comp_method2char[comp_idx[c]];
+            }
+            if (!*cstr) *cstr = '.';
+
+            if ((int)kh_key(cu_size, k) < 0)
+                fprintf(outfp, "BLOCK %8s", "CORE");
+            else
+                fprintf(outfp, "BLOCK %8d", kh_key(cu_size, k));
+            fprintf(outfp, " %12"PRId64" %12"PRId64, usize, csize);
+            double f = 100*(csize+.0001)/(usize+.0001);
+            if (f > 999)
+                fprintf(outfp, "   >999%% %-7s", cstr);
+            else
+                fprintf(outfp, " %6.2f%% %-7s", f, cstr);
+
+            int n, j, *dsa = cram_cid2ds_query(cid2ds, kh_key(cu_size, k), &n);
+            for (j = 0; j < n; j++) {
+                int d = dsa[j];
+                if (d > 65535)
+                    fprintf(outfp, " %c%c%c", d>>16, (d>>8)&0xff, d&0xff);
+                else
+                    fprintf(outfp, " %c%c", (d>>8)&0xff, d&0xff);
+            }
+        }
+
+        if ((int)kh_key(cu_size, k) >= 0 &&
+            (int)kh_key(cu_size, k) == ref_seq_blk) {
+            fprintf(outfp, " embedded_ref");
+        }
+        fprintf(outfp, "\n");
+
+        tot_size += total_csize(&kh_value(cu_size, k));
+    }
+
+    free(sorted_blocks);
+
+    return tot_size;
+}
+
+/* Main processing loop */
+static int cram_size(hFILE *hf_in, samFile *in, sam_hdr_t *h, FILE *outfp,
+                     int verbose, int encodings) {
+    cram_fd *in_c;
+    cram_container *c = NULL;
+    cram_block *blk = NULL;
+    cram_block_slice_hdr *shdr = NULL;
+    khiter_t k;
+    int ret;
+    cram_cid2ds_t *cid2ds = NULL;
+    khash_t(cu) *cu_size = kh_init(cu);
+    int ref_seq_blk_used = -1;
+    int64_t nseqs = 0, nbases = 0, ncont = 0, nslice = 0;
+
+    if (!in->is_cram) {
+        print_error("cram_size", "Input is not a CRAM file");
+        goto err;
+    }
+    in_c = in->fp.cram; // low level htslib abuse?
+    while ((c = cram_read_container(in_c))) {
+        if (cram_container_is_empty(in_c)) {
+            cram_block *blk;
+            // Container compression header
+            if (!(blk = cram_read_block(in_c)))
+                goto err;
+            cram_free_block(blk);
+            cram_free_container(c);
+            c = NULL; blk = NULL;
+            continue;
+        }
+
+        nseqs  += cram_container_get_num_records(c);
+        nbases += cram_container_get_num_bases(c);
+
+        // Container compression header
+        int32_t num_slices;
+        if (!(blk = cram_read_block(in_c)))
+            goto err;
+
+        // Decode compression header...
+        cram_block_compression_hdr *chdr;
+        chdr = cram_decode_compression_header(in_c, blk);
+
+        if (encodings) {
+            kstring_t ks = KS_INITIALIZE;
+            if (cram_describe_encodings(chdr, &ks) < 0)
+                goto err;
+
+            fprintf(outfp, "Container encodings\n%s\n", ks_str(&ks));
+
+            ks_free(&ks);
+        }
+
+        cid2ds = cram_update_cid2ds_map(chdr, cid2ds);
+
+        cram_free_block(blk);
+        blk = NULL;
+
+        cram_free_compression_header(chdr);
+
+        // Container num_blocks can be invalid, due to a bug.
+        // Instead we iterate in slice context instead.
+        (void)cram_container_get_landmarks(c, &num_slices);
+        ncont++;
+        nslice += num_slices;
+
+        int i, j;
+        for (i = 0; i < num_slices; i++) {
+            // Slice header
+            if (!(blk = cram_read_block(in_c)))
+                goto err;
+            if (!(shdr = cram_decode_slice_header(in_c, blk)))
+                goto err;
+            cram_free_block(blk);
+            blk = NULL;
+
+            int ref_seq_blk = cram_slice_hdr_get_embed_ref_id(shdr);
+            int num_blocks = cram_slice_hdr_get_num_blocks(shdr);
+
+            // Embedded reference.  Check it's consistent (if used this is
+            // an almost guaranteed certainty, so we take the easy route).
+            if (ref_seq_blk >= 0) {
+                if (ref_seq_blk_used == -1)
+                    ref_seq_blk_used = ref_seq_blk;
+                else if (ref_seq_blk_used != ref_seq_blk)
+                    fprintf(samtools_stderr, "Embedded reference is not consistently using the same Content-Id.\n"
+                            "Reported figures for reference will be invalid.\n");
+            }
+
+            // Slice data blocks
+            for (j = 0; j < num_blocks; j++) {
+                // read and discard, unless it's the ref-ID block
+                if (!(blk = cram_read_block(in_c)))
+                    goto err;
+
+                int32_t csize = cram_block_get_comp_size(blk);
+                int32_t usize = cram_block_get_uncomp_size(blk);
+                int cid = cram_block_get_content_id(blk);
+                enum cram_block_method method = cram_block_get_method(blk);
+
+                // Expand comp to the internal sub-formats, eg
+                // rANS order-0/1, PACK+RLE, etc.
+                cram_method_details *cm;
+                cm = cram_expand_method(cram_block_get_data(blk),
+                                        cram_block_get_comp_size(blk),
+                                        method);
+                if (!cm)
+                    goto err;
+                enum comp_expanded comp
+                    = comp_method2expanded(cm);
+                free(cm);
+
+                k = kh_put(cu, cu_size, cid, &ret);
+                if (ret < 0)
+                    goto err;
+                if (ret == 0) {
+                    kh_value(cu_size, k).csize[comp] += csize;
+                    kh_value(cu_size, k).usize[comp] += usize;
+                } else {
+                    memset(&kh_value(cu_size, k), 0, sizeof(cusize_t));
+                    kh_value(cu_size, k).csize[comp]  = csize;
+                    kh_value(cu_size, k).usize[comp]  = usize;
+                }
+
+                cram_free_block(blk);
+                blk = NULL;
+            }
+            cram_free_slice_header(shdr);
+            shdr = NULL;
+        }
+
+        cram_free_container(c);
+        c = NULL;
+    }
+
+    off_t tot_size = report_size(outfp, verbose, ref_seq_blk_used,
+                                 cu_size, cid2ds);
+    if (tot_size < 0)
+        goto err;
+
+    kh_destroy(cu, cu_size);
+    cram_cid2ds_free(cid2ds);
+
+    off_t end = htell(hf_in);
+
+    fprintf(outfp, "\n");
+    fprintf(outfp, "Number of containers  %18"PRId64"\n", ncont);
+    fprintf(outfp, "Number of slices      %18"PRId64"\n", nslice);
+    fprintf(outfp, "Number of sequences   %18"PRId64"\n", nseqs);
+    fprintf(outfp, "Number of bases       %18"PRId64"\n", nbases);
+    fprintf(outfp, "Total file size       %18"PRId64"\n", (int64_t) end);
+    fprintf(outfp, "Format overhead size  %18"PRId64"\n", (int64_t) (end - tot_size));
+
+    return 0;
+
+ err:
+    // Report anyway so we can get stats on partial files, but be
+    // sure to error too.
+    report_size(outfp, verbose, ref_seq_blk_used, cu_size, cid2ds);
+
+    print_error("cram_size", "Failed in decoding CRAM file");
+    if (blk)
+        cram_free_block(blk);
+    if (shdr)
+        cram_free_slice_header(shdr);
+    if (c)
+        cram_free_container(c);
+    if (cid2ds)
+        cram_cid2ds_free(cid2ds);
+
+    return -1;
+}
+
+/* main() for cram_size */
+int main_cram_size(int argc, char *argv[]) {
+    int c, usage = 0, verbose = 0, encodings = 0;
+    sam_hdr_t *h = 0;
+    hFILE *hf_in = NULL;
+    samFile *in = NULL;
+    sam_global_args ga;
+    FILE *outfp = samtools_stdout;
+
+    static const struct option lopts[] = {
+        {"output", required_argument, NULL, 'o'},
+        {"verbose",  no_argument, NULL, 'v'},
+        {"encodings", no_argument, NULL, 'e'},
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', '-', '-'),
+        { NULL, 0, NULL, 0 }
+    };
+
+    sam_global_args_init(&ga);
+
+    while ((c = getopt_long(argc, argv, "vo:e", lopts, NULL)) >= 0) {
+        switch (c) {
+        case 'o':
+            if (!(outfp = fopen(optarg, "w"))) {
+                perror(optarg);
+                goto err;
+            }
+            break;
+
+        case 'v':
+            verbose++;
+            break;
+
+        case 'e':
+            encodings++;
+            break;
+
+        default:
+            if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+            /* else fall-through */
+        case '?': usage=1; break;
+        }
+    }
+
+    if ((optind == argc && isatty(0)) || usage) {
+        fprintf(samtools_stdout, "Usage: samtools cram_size [-ve] [-o out.size] [in.cram]\n");
+        return 0;
+    }
+
+    char *fn = optind < argc ? argv[optind] : "-";
+
+    // We want access to in->fp.cram->fp, but this is an opaque struct so we
+    // can't get that.  However we opened with hopen and then reopen as
+    // CRAM with hts_hopen, which will swallow the initial hFILE and take
+    // owenership of it.  Hence we now know in->fp.cram->fp.
+    if (!(hf_in = hopen(fn, "r"))) {
+        print_error_errno("cram_size", "failed to open file '%s'", fn);
+        return 1;
+    }
+    if (!(in = hts_hopen(hf_in, fn, "r"))) {
+        print_error_errno("cram_size", "failed to open file '%s'", fn);
+        goto err;
+    }
+
+    if (!(h = sam_hdr_read(in)))
+        goto err;
+
+    int ret = cram_size(hf_in, in, h, outfp, verbose, encodings);
+    sam_hdr_destroy(h);
+    sam_close(in);
+    if (outfp != samtools_stdout)
+        fclose(outfp);
+
+    return ret ? 1 : 0;
+
+ err:
+    if (in)
+        sam_close(in);
+    if (h)
+        sam_hdr_destroy(h);
+
+    return 1;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/cut_target.c

@@ -0,0 +1,257 @@
+/*  cut_target.c -- targetcut subcommand.
+
+    Copyright (C) 2011 Broad Institute.
+    Copyright (C) 2012-2013, 2015, 2016, 2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include "htslib/hts.h"
+#include "htslib/sam.h"
+#include "htslib/faidx.h"
+#include "samtools.h"
+#include "sam_opts.h"
+
+#define ERR_DEP 0.83
+
+typedef struct {
+    int e[2][3], p[2][2];
+} score_param_t;
+
+/* Note that although the two matrics have 10 parameters in total, only 4
+ * (probably 3) are free.  Changing the scoring matrices in a sort of symmetric
+ * way will not change the result. */
+static score_param_t g_param = { {{0,0,0},{-4,1,6}}, {{0,-14000}, {0,0}} };
+
+typedef struct {
+    int min_baseQ, tid, max_bases;
+    uint16_t *bases;
+    samFile *fp;
+    sam_hdr_t *h;
+    char *ref;
+    hts_pos_t len;
+    faidx_t *fai;
+    errmod_t *em;
+} ct_t;
+
+static uint16_t gencns(ct_t *g, int n, const bam_pileup1_t *plp)
+{
+    int i, j, ret, tmp, k, sum[4], qual;
+    float q[16];
+    if (n > g->max_bases) { // enlarge g->bases
+        g->max_bases = n;
+        kroundup32(g->max_bases);
+        g->bases = realloc(g->bases, (size_t) g->max_bases * 2);
+    }
+    for (i = k = 0; i < n; ++i) {
+        const bam_pileup1_t *p = plp + i;
+        uint8_t *seq;
+        int q, baseQ, b;
+        if (p->is_refskip || p->is_del) continue;
+        baseQ = bam_get_qual(p->b)[p->qpos];
+        if (baseQ < g->min_baseQ) continue;
+        seq = bam_get_seq(p->b);
+        b = seq_nt16_int[bam_seqi(seq, p->qpos)];
+        if (b > 3) continue;
+        q = baseQ < p->b->core.qual? baseQ : p->b->core.qual;
+        if (q < 4) q = 4;
+        if (q > 63) q = 63;
+        g->bases[k++] = q<<5 | bam_is_rev(p->b)<<4 | b;
+    }
+    if (k == 0) return 0;
+    errmod_cal(g->em, k, 4, g->bases, q);
+    for (i = 0; i < 4; ++i) sum[i] = (int)(q[i<<2|i] + .499) << 2 | i;
+    for (i = 1; i < 4; ++i) // insertion sort
+        for (j = i; j > 0 && sum[j] < sum[j-1]; --j)
+            tmp = sum[j], sum[j] = sum[j-1], sum[j-1] = tmp;
+    qual = (sum[1]>>2) - (sum[0]>>2);
+    k = k < 256? k : 255;
+    ret = (qual < 63? qual : 63) << 2 | (sum[0]&3);
+    return ret<<8|k;
+}
+
+static void process_cns(sam_hdr_t *h, int tid, hts_pos_t l, uint16_t *cns)
+{
+    int64_t i, s;
+    int f[2][2], *prev, *curr, *swap_tmp;
+    uint8_t *b; // backtrack array
+    b = calloc(l, 1);
+    f[0][0] = f[0][1] = 0;
+    prev = f[0]; curr = f[1];
+    // fill the backtrack matrix
+    for (i = 0; i < l; ++i) {
+        int c = (cns[i] == 0)? 0 : (cns[i]>>8 == 0)? 1 : 2;
+        int tmp0, tmp1;
+        // compute f[0]
+        tmp0 = prev[0] + g_param.e[0][c] + g_param.p[0][0]; // (s[i+1],s[i])=(0,0)
+        tmp1 = prev[1] + g_param.e[0][c] + g_param.p[1][0]; // (0,1)
+        if (tmp0 > tmp1) curr[0] = tmp0, b[i] = 0;
+        else curr[0] = tmp1, b[i] = 1;
+        // compute f[1]
+        tmp0 = prev[0] + g_param.e[1][c] + g_param.p[0][1]; // (s[i+1],s[i])=(1,0)
+        tmp1 = prev[1] + g_param.e[1][c] + g_param.p[1][1]; // (1,1)
+        if (tmp0 > tmp1) curr[1] = tmp0, b[i] |= 0<<1;
+        else curr[1] = tmp1, b[i] |= 1<<1;
+        // swap
+        swap_tmp = prev; prev = curr; curr = swap_tmp;
+    }
+    // backtrack
+    s = prev[0] > prev[1]? 0 : 1;
+    for (i = l - 1; i > 0; --i) {
+        b[i] |= s<<2;
+        s = b[i]>>s&1;
+    }
+    // print
+    for (i = 0, s = -1; i < INT64_MAX && i <= l; ++i) {
+        if (i == l || ((b[i]>>2&3) == 0 && s >= 0)) {
+            if (s >= 0) {
+                int64_t j;
+                printf("%s:%"PRId64"-%"PRId64"\t0\t%s\t%"PRId64"\t60\t%"PRId64"M\t*\t0\t0\t", sam_hdr_tid2name(h, tid), s+1, i, sam_hdr_tid2name(h, tid), s+1, i-s);
+                for (j = s; j < i; ++j) {
+                    int c = cns[j]>>8;
+                    if (c == 0) putchar('N');
+                    else putchar("ACGT"[c&3]);
+                }
+                putchar('\t');
+                for (j = s; j < i; ++j)
+                    putchar(33 + (cns[j]>>8>>2));
+                putchar('\n');
+            }
+            //if (s >= 0) printf("%s\t%d\t%d\t%d\n", h->target_name[tid], s, i, i - s);
+            s = -1;
+        } else if ((b[i]>>2&3) && s < 0) s = i;
+    }
+    free(b);
+}
+
+static int read_aln(void *data, bam1_t *b)
+{
+    ct_t *g = (ct_t*)data;
+    int ret;
+    while (1)
+    {
+        ret = sam_read1(g->fp, g->h, b);
+        if ( ret<0 ) break;
+        if ( b->core.flag & (BAM_FUNMAP | BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP) ) continue;
+        if ( g->fai && b->core.tid >= 0 ) {
+            if (b->core.tid != g->tid) { // then load the sequence
+                free(g->ref);
+                g->ref = fai_fetch64(g->fai, sam_hdr_tid2name(g->h, b->core.tid), &g->len);
+                g->tid = b->core.tid;
+            }
+            sam_prob_realn(b, g->ref, g->len, 1<<1|1);
+        }
+        break;
+    }
+    return ret;
+}
+
+int main_cut_target(int argc, char *argv[])
+{
+    int c, tid, pos, n, lasttid = -1, usage = 0, status = EXIT_SUCCESS;
+    hts_pos_t l, max_l;
+    const bam_pileup1_t *p;
+    bam_plp_t plp;
+    uint16_t *cns;
+    ct_t g;
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', 'f', '-'),
+        { NULL, 0, NULL, 0 }
+    };
+
+    memset(&g, 0, sizeof(ct_t));
+    g.min_baseQ = 13; g.tid = -1;
+    while ((c = getopt_long(argc, argv, "f:Q:i:o:0:1:2:", lopts, NULL)) >= 0) {
+        switch (c) {
+            case 'Q': g.min_baseQ = atoi(optarg); break; // quality cutoff
+            case 'i': g_param.p[0][1] = -atoi(optarg); break; // 0->1 transition (in) PENALTY
+            case '0': g_param.e[1][0] = atoi(optarg); break; // emission SCORE
+            case '1': g_param.e[1][1] = atoi(optarg); break;
+            case '2': g_param.e[1][2] = atoi(optarg); break;
+            default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+                      /* else fall-through */
+            case '?': usage=1; break;
+        }
+    }
+    if (ga.reference) {
+        g.fai = fai_load(ga.reference);
+        if (g.fai == 0) fprintf(stderr, "[%s] fail to load the fasta index.\n", __func__);
+    }
+    if (usage || argc == optind) {
+        fprintf(stderr, "Usage: samtools targetcut [-Q minQ] [-i inPen] [-0 em0] [-1 em1] [-2 em2] <in.bam>\n");
+        sam_global_opt_help(stderr, "-.--f--.");
+        return 1;
+    }
+    l = max_l = 0; cns = 0;
+    g.fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (g.fp == NULL) {
+        print_error_errno("targetcut", "can't open \"%s\"", argv[optind]);
+        return 1;
+    }
+
+    g.h = sam_hdr_read(g.fp);
+    if (g.h == NULL) {
+        print_error("targetcut", "couldn't read header for \"%s\"", argv[optind]);
+        sam_close(g.fp);
+        return 1;
+    }
+    g.em = errmod_init(1. - ERR_DEP);
+    plp = bam_plp_init(read_aln, &g);
+    while ((p = bam_plp_auto(plp, &tid, &pos, &n)) != 0) {
+        if (tid < 0) break;
+        if (tid != lasttid) { // change of chromosome
+            if (cns) process_cns(g.h, lasttid, l, cns);
+            if (max_l < sam_hdr_tid2len(g.h, tid)) {
+                max_l = sam_hdr_tid2len(g.h, tid);
+                kroundup32(max_l);
+                cns = realloc(cns, max_l * 2);
+            }
+            l = sam_hdr_tid2len(g.h, tid);
+            memset(cns, 0, max_l * 2);
+            lasttid = tid;
+        }
+        cns[pos] = gencns(&g, n, p);
+    }
+    process_cns(g.h, lasttid, l, cns);
+
+    if (n < 0) {
+        print_error("targetcut", "error reading from \"%s\"", argv[optind]);
+        status = EXIT_FAILURE;
+    }
+
+    free(cns);
+    sam_hdr_destroy(g.h);
+    bam_plp_destroy(plp);
+    sam_close(g.fp);
+    if (g.fai) {
+        fai_destroy(g.fai); free(g.ref);
+    }
+    errmod_destroy(g.em);
+    free(g.bases);
+    sam_global_args_free(&ga);
+    return status;
+}

falcon/lib/python3.10/site-packages/pysam/include/samtools/cut_target.c.pysam.c

@@ -0,0 +1,259 @@
+#include "samtools.pysam.h"
+
+/*  cut_target.c -- targetcut subcommand.
+
+    Copyright (C) 2011 Broad Institute.
+    Copyright (C) 2012-2013, 2015, 2016, 2019 Genome Research Ltd.
+
+    Author: Heng Li <lh3@sanger.ac.uk>
+
+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.  */
+
+#include <config.h>
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include "htslib/hts.h"
+#include "htslib/sam.h"
+#include "htslib/faidx.h"
+#include "samtools.h"
+#include "sam_opts.h"
+
+#define ERR_DEP 0.83
+
+typedef struct {
+    int e[2][3], p[2][2];
+} score_param_t;
+
+/* Note that although the two matrics have 10 parameters in total, only 4
+ * (probably 3) are free.  Changing the scoring matrices in a sort of symmetric
+ * way will not change the result. */
+static score_param_t g_param = { {{0,0,0},{-4,1,6}}, {{0,-14000}, {0,0}} };
+
+typedef struct {
+    int min_baseQ, tid, max_bases;
+    uint16_t *bases;
+    samFile *fp;
+    sam_hdr_t *h;
+    char *ref;
+    hts_pos_t len;
+    faidx_t *fai;
+    errmod_t *em;
+} ct_t;
+
+static uint16_t gencns(ct_t *g, int n, const bam_pileup1_t *plp)
+{
+    int i, j, ret, tmp, k, sum[4], qual;
+    float q[16];
+    if (n > g->max_bases) { // enlarge g->bases
+        g->max_bases = n;
+        kroundup32(g->max_bases);
+        g->bases = realloc(g->bases, (size_t) g->max_bases * 2);
+    }
+    for (i = k = 0; i < n; ++i) {
+        const bam_pileup1_t *p = plp + i;
+        uint8_t *seq;
+        int q, baseQ, b;
+        if (p->is_refskip || p->is_del) continue;
+        baseQ = bam_get_qual(p->b)[p->qpos];
+        if (baseQ < g->min_baseQ) continue;
+        seq = bam_get_seq(p->b);
+        b = seq_nt16_int[bam_seqi(seq, p->qpos)];
+        if (b > 3) continue;
+        q = baseQ < p->b->core.qual? baseQ : p->b->core.qual;
+        if (q < 4) q = 4;
+        if (q > 63) q = 63;
+        g->bases[k++] = q<<5 | bam_is_rev(p->b)<<4 | b;
+    }
+    if (k == 0) return 0;
+    errmod_cal(g->em, k, 4, g->bases, q);
+    for (i = 0; i < 4; ++i) sum[i] = (int)(q[i<<2|i] + .499) << 2 | i;
+    for (i = 1; i < 4; ++i) // insertion sort
+        for (j = i; j > 0 && sum[j] < sum[j-1]; --j)
+            tmp = sum[j], sum[j] = sum[j-1], sum[j-1] = tmp;
+    qual = (sum[1]>>2) - (sum[0]>>2);
+    k = k < 256? k : 255;
+    ret = (qual < 63? qual : 63) << 2 | (sum[0]&3);
+    return ret<<8|k;
+}
+
+static void process_cns(sam_hdr_t *h, int tid, hts_pos_t l, uint16_t *cns)
+{
+    int64_t i, s;
+    int f[2][2], *prev, *curr, *swap_tmp;
+    uint8_t *b; // backtrack array
+    b = calloc(l, 1);
+    f[0][0] = f[0][1] = 0;
+    prev = f[0]; curr = f[1];
+    // fill the backtrack matrix
+    for (i = 0; i < l; ++i) {
+        int c = (cns[i] == 0)? 0 : (cns[i]>>8 == 0)? 1 : 2;
+        int tmp0, tmp1;
+        // compute f[0]
+        tmp0 = prev[0] + g_param.e[0][c] + g_param.p[0][0]; // (s[i+1],s[i])=(0,0)
+        tmp1 = prev[1] + g_param.e[0][c] + g_param.p[1][0]; // (0,1)
+        if (tmp0 > tmp1) curr[0] = tmp0, b[i] = 0;
+        else curr[0] = tmp1, b[i] = 1;
+        // compute f[1]
+        tmp0 = prev[0] + g_param.e[1][c] + g_param.p[0][1]; // (s[i+1],s[i])=(1,0)
+        tmp1 = prev[1] + g_param.e[1][c] + g_param.p[1][1]; // (1,1)
+        if (tmp0 > tmp1) curr[1] = tmp0, b[i] |= 0<<1;
+        else curr[1] = tmp1, b[i] |= 1<<1;
+        // swap
+        swap_tmp = prev; prev = curr; curr = swap_tmp;
+    }
+    // backtrack
+    s = prev[0] > prev[1]? 0 : 1;
+    for (i = l - 1; i > 0; --i) {
+        b[i] |= s<<2;
+        s = b[i]>>s&1;
+    }
+    // print
+    for (i = 0, s = -1; i < INT64_MAX && i <= l; ++i) {
+        if (i == l || ((b[i]>>2&3) == 0 && s >= 0)) {
+            if (s >= 0) {
+                int64_t j;
+                fprintf(samtools_stdout, "%s:%"PRId64"-%"PRId64"\t0\t%s\t%"PRId64"\t60\t%"PRId64"M\t*\t0\t0\t", sam_hdr_tid2name(h, tid), s+1, i, sam_hdr_tid2name(h, tid), s+1, i-s);
+                for (j = s; j < i; ++j) {
+                    int c = cns[j]>>8;
+                    if (c == 0) fputc('N', samtools_stdout);
+                    else fputc("ACGT"[c&3], samtools_stdout);
+                }
+                fputc('\t', samtools_stdout);
+                for (j = s; j < i; ++j)
+                    fputc(33 + (cns[j]>>8>>2), samtools_stdout);
+                fputc('\n', samtools_stdout);
+            }
+            //if (s >= 0) fprintf(samtools_stdout, "%s\t%d\t%d\t%d\n", h->target_name[tid], s, i, i - s);
+            s = -1;
+        } else if ((b[i]>>2&3) && s < 0) s = i;
+    }
+    free(b);
+}
+
+static int read_aln(void *data, bam1_t *b)
+{
+    ct_t *g = (ct_t*)data;
+    int ret;
+    while (1)
+    {
+        ret = sam_read1(g->fp, g->h, b);
+        if ( ret<0 ) break;
+        if ( b->core.flag & (BAM_FUNMAP | BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP) ) continue;
+        if ( g->fai && b->core.tid >= 0 ) {
+            if (b->core.tid != g->tid) { // then load the sequence
+                free(g->ref);
+                g->ref = fai_fetch64(g->fai, sam_hdr_tid2name(g->h, b->core.tid), &g->len);
+                g->tid = b->core.tid;
+            }
+            sam_prob_realn(b, g->ref, g->len, 1<<1|1);
+        }
+        break;
+    }
+    return ret;
+}
+
+int main_cut_target(int argc, char *argv[])
+{
+    int c, tid, pos, n, lasttid = -1, usage = 0, status = EXIT_SUCCESS;
+    hts_pos_t l, max_l;
+    const bam_pileup1_t *p;
+    bam_plp_t plp;
+    uint16_t *cns;
+    ct_t g;
+
+    sam_global_args ga = SAM_GLOBAL_ARGS_INIT;
+    static const struct option lopts[] = {
+        SAM_OPT_GLOBAL_OPTIONS('-', 0, '-', '-', 'f', '-'),
+        { NULL, 0, NULL, 0 }
+    };
+
+    memset(&g, 0, sizeof(ct_t));
+    g.min_baseQ = 13; g.tid = -1;
+    while ((c = getopt_long(argc, argv, "f:Q:i:o:0:1:2:", lopts, NULL)) >= 0) {
+        switch (c) {
+            case 'Q': g.min_baseQ = atoi(optarg); break; // quality cutoff
+            case 'i': g_param.p[0][1] = -atoi(optarg); break; // 0->1 transition (in) PENALTY
+            case '0': g_param.e[1][0] = atoi(optarg); break; // emission SCORE
+            case '1': g_param.e[1][1] = atoi(optarg); break;
+            case '2': g_param.e[1][2] = atoi(optarg); break;
+            default:  if (parse_sam_global_opt(c, optarg, lopts, &ga) == 0) break;
+                      /* else fall-through */
+            case '?': usage=1; break;
+        }
+    }
+    if (ga.reference) {
+        g.fai = fai_load(ga.reference);
+        if (g.fai == 0) fprintf(samtools_stderr, "[%s] fail to load the fasta index.\n", __func__);
+    }
+    if (usage || argc == optind) {
+        fprintf(samtools_stderr, "Usage: samtools targetcut [-Q minQ] [-i inPen] [-0 em0] [-1 em1] [-2 em2] <in.bam>\n");
+        sam_global_opt_help(samtools_stderr, "-.--f--.");
+        return 1;
+    }
+    l = max_l = 0; cns = 0;
+    g.fp = sam_open_format(argv[optind], "r", &ga.in);
+    if (g.fp == NULL) {
+        print_error_errno("targetcut", "can't open \"%s\"", argv[optind]);
+        return 1;
+    }
+
+    g.h = sam_hdr_read(g.fp);
+    if (g.h == NULL) {
+        print_error("targetcut", "couldn't read header for \"%s\"", argv[optind]);
+        sam_close(g.fp);
+        return 1;
+    }
+    g.em = errmod_init(1. - ERR_DEP);
+    plp = bam_plp_init(read_aln, &g);
+    while ((p = bam_plp_auto(plp, &tid, &pos, &n)) != 0) {
+        if (tid < 0) break;
+        if (tid != lasttid) { // change of chromosome
+            if (cns) process_cns(g.h, lasttid, l, cns);
+            if (max_l < sam_hdr_tid2len(g.h, tid)) {
+                max_l = sam_hdr_tid2len(g.h, tid);
+                kroundup32(max_l);
+                cns = realloc(cns, max_l * 2);
+            }
+            l = sam_hdr_tid2len(g.h, tid);
+            memset(cns, 0, max_l * 2);
+            lasttid = tid;
+        }
+        cns[pos] = gencns(&g, n, p);
+    }
+    process_cns(g.h, lasttid, l, cns);
+
+    if (n < 0) {
+        print_error("targetcut", "error reading from \"%s\"", argv[optind]);
+        status = EXIT_FAILURE;
+    }
+
+    free(cns);
+    sam_hdr_destroy(g.h);
+    bam_plp_destroy(plp);
+    sam_close(g.fp);
+    if (g.fai) {
+        fai_destroy(g.fai); free(g.ref);
+    }
+    errmod_destroy(g.em);
+    free(g.bases);
+    sam_global_args_free(&ga);
+    return status;
+}