* Return true iff the given Coord is inside this Interval, without * requiring orientations to match. */

* Return a pointer to the E vector at the given row and column. Note: * here row refers to rows of vectors, not rows of elements. */

* Calculate size of file with given name. */

* Return a pointer to the F vector at the given row and column. Note: * here row refers to rows of vectors, not rows of elements. */

* Return true if this alignment is to the Watson strand. */

* Set the given cell's H mask. This is the mask of remaining legal ways to * backtrack from the H cell at this coordinate. It's 5 bits long and has

* Invert positions of edits so that they're with respect to the other end * of the alignment. The assumption is that the .pos fields of the edits

* Return true if this Edit is either an initialized deletion or an * initialized insertion. */

* Return true iff this branch ends in a solution to the backtrace problem. */

* Return 1 if a 2-bit-encoded base ('i') matches any bit in the mask ('j') and * the mask < 16. Returns -1 if either the reference or the read chara

* Return number of mismatches in the alignment. */

* Open the next file in the list of input files. */

* Parse a name from fb_ and store in r. Assume that the next * character obtained via fb_.get() is the first character of * the sequence and the st

* Set alignment score for this alignment. */

* Set the upstream-most reference offset involved in the alignment, and * the extent of the alignment (w/r/t the reference) */

* Return a read-only pointer to the beginning of the top side. */

* Return the size, i.e. the total number of branches contained. */

* Once the constrained seed is completely explored, call this * function to check whether there were *at least* as many * dissimilarities as requi

* Return true iff the alignment params are such that it's possible for a * read to be suppressed for being repetitive. */

* Allocate new, bigger buffer and copy old contents into it. If * requested size can be accommodated by current buffer, do nothing. */

* Set all bits in specified range of elements in list array to 0. */

* Initialize this WalkResult. */

* Assuming this AlnRes is an alignment for 'rd', check that the alignment and * 'rd' are compatible with the corresponding reference sequence. */

* Pretty-print the Ebwt to the given output stream. */

* Print a detailed usage message to the provided output stream. */

* Called by the aligner when a new unpaired or paired alignment is * discovered in the given stage. This function checks whether the * addition of

* If size is less than requested size, resize up to at least sz * and set cur_ to requested sz. */

* Either reverse or reverse-complement (depending on "color") this * DNA buffer in-place. */

* Convert locus to BW row it corresponds to. */

* Return a writeable version of the raw buffer. */

* Take an ASCII-encoded quality value and convert it to a Phred33 * ASCII char. */

* Clip away portions of the alignment that are outside the given bounds. * Clipping is soft if soft == true, hard otherwise. Assuming for now that

* Return the number of SSERegI's you need to skip over to get from one * cell to the cell one column over from it. */

* Return the reverse complement of a bit-encoded nucleotide. */

* Return true when there's nothing left for next(). */

* Allocate a T array of length sz_ and store in list_. Also, * tally into the global memory tally. */

* Take an offset into the joined text and translate it into the * reference of the index it falls on, the offset into the reference, * and the lengt

* Given top and bot loci, calculate counts of all four DNA chars up to * those loci. Used for more advanced backtracking-search. */

wait for data, if none in the queue

* Query the relevant set of caches, looking for a QVal to go with * the provided QKey. If a QVal is found and which is non-NULL, * *which is set

* Reset so that next call to nextBatch* gets the first batch. */

* Set whether this alignment is unpaired, or is mate #1 or mate #2 in a * paired-end alignment. */

* Set the primary flag. */

* Merge (add) the counters in the given SwResult object into this * SwMetrics object. */

* Return true iff we're in -M mode. */

* Align read 'rd' to reference using read & reference information given * last time init() was called. */

* Append char c. */

* Append DNA character. */

* Return true iff the read substring is cacheable. */

* Clear the cache, i.e. turn it over. All HitGens referring to * ranges in this cache will become invalid and the corresponding * reads will have

* Count all occurrences of character c from the beginning of the * forward side to <by,bp> and add in the occ[] count up to the side * break just

* Another interface for running a case. */

* If false, there's no need to seek any more unpaired alignments for the * specified mate. Note: this doesn't necessarily mean we can stop looking

* Return copy of uint16_t argument with byte order reversed. */

* Allocate new, bigger buffer. If requested size can be * accommodated by current buffer, do nothing. */

* Calculate a vector containing the sizes of all of the patterns in * all of the given input files, in order. Returns the total size of * all refer

* Return fragment length inferred by a paired-end alignment, or -1 if the * alignment is not part of a pair. */

* Return a single base of the reference. Calling this repeatedly * is not an efficient way to retrieve bases from the reference; * use loadStretch(

* Initialize with a new alignment problem. */

* Get the next valid alignment given the backtrace problem. Return false * if there is no valid solution, e.g., if */

* Return the number of orientation/offsets into the read that have * at least one seed hit. */

* Return the number of different seed offsets possible. */

* Return the number of reference substrings associated with a read * substring. */

Use this standard bit-bashing population count

* Print a summary usage message to the provided output stream. */

* Print a summary usage message to the provided output stream. */

* Reports a matrix of results, incl. column labels, to an OutFileBuf. * Optionally also sends results to stderr (unbuffered). Can optionally * pr

* Return true iff element i has been reported. */