* Calculate SideLocus based on a row and other relevant * information about the shape of the Ebwt. */

* Make this score invalid (and therefore <= all other scores). */

* Return the number of records that have been finished so far. */

* Return true iff this alignment is from a paired-end read. */

* Trim len characters from the end of the string. */

* Return true iff this score has a valid value. */

* Return true iff a -m or -M limit was set by the user. */

* Initialize state machine with a new read. The state we start in depends * on whether it's paired-end or unpaired. */

* Return the number of records that have been flushed so far. */

* Return the number of ranges being held. */

* Remove the topmost element. */

Return true iff the Ebwt is currently in memory

* Return true iff the given cell has its reportedThru bit set. */

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

* Sort the edits in the provided list. */

* Add all of the cells involved in the given alignment to the database. */

* Return true iff we've been collecting debug cells. */

* Return true iff this Descent has been initialized. */

* Set all counters to 0. */

* Clear all contents. */

* Return the checkpointed H, E, or F score from the given cell. */

* Return the number of times this reference substring occurs in the * reference, which is also the size of the 'offs' TSlice. */

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

* Tally a memory free of size amt bytes. */

* Ensure that there is sufficient capacity to expand to include * 'thresh' more elements without having to expand. */

* Return true iff this Edit is an initialized mismatch. */

* Get next 2-bit unsigned integer. */

* Return the identifier for the reference that the alignment * occurred in. */

* Reset to uninitialized state. */

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

* Return true iff the machine running this program is big-endian. */

* Caller uses this member function to indicate that one additional * concordant alignment has been found. */

* Return the penalty incurred by a mismatch at an alignment column * with read character 'rdc' reference mask 'refm' and quality 'q'. * * qs sho

* Remove an element from the top of the stack. */

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

* Check that pool is internally consistent. */

* Get second-best score observed so far for paired-end read. */

* Set the memory category for this object. */

* Return mutable list item at offset 'off' */

* Extract key summaries from this SeedResults and put into 'ssum'. */

* Print friendly-ish message pertaining to failed system call. */

* Called to indicate that the aligner has finished searching for * alignments. This gives us a chance to finalize our state. * * TODO: Keep track

* Simple, fast helper for determining if a character is a newline. */

* Return true iff we have already encountered a number of alignments that * exceeds the -m/-M ceiling. TODO: how does this distinguish between *

* Return the marginal penalty incurred by an N mismatch at a read * position with quality 'q'. */

* Remove element from set. */

* Add 1 object to the list. */

* Return the element in the E matrix at element row, col. */

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

* Erase element at offset idx. */

* Return the element in the F matrix at element row, col. */

* Populate given counters with the number of various kinds of alignments * to report for this read. Concordant alignments are preferable to (and *

* Caller gives us score_en, row and col. We figure out score_st and len_ * by comparing characters from the strings. * * If this branch comes afte

* Initialize a new descent root. */

* Return true iff the given row/col is checkpointed. */

* Advance cursor to next element */

* Get best score observed so far for paired-end read. */

* Return best alignment score for end 1 or 2 whether the read is * a pair or not. */

* Return best unchosen alignment score for end 1 or 2 whether * the read is a pair or not. */

* Merge a set of specific metrics into this object. */

* Return the peak amount of memory allocated. */

* Check that GWHit is internally consistent. If a pointer to an * EList of GWStates is given, we assume that it is the EList * corresponding to t

* Check that SideLocus is internally consistent and consistent * with the (provided) EbwtParams. */

* Set the number of reference Ns covered by the alignment. */