New upstream version 2.3.4.2

cmake_minimum_required(VERSION 2.8) 

cmake_policy(SET CMP0048 NEW)

cmake_policy(SET CMP0005 NEW)

project(bowtie2 LANGUAGES CXX VERSION "2.3.4.2")

enable_testing()

include(CTest)

include(ProcessorCount)

include(CheckSymbolExists)

ProcessorCount(NUM_CORES)

option(BOWTIE_MM "enable bowtie2 memory mapping" ON)

option(BOWITE_SHARED_MM "enable shared memory mapping" ON)

set(CMAKE_CXX_STANDARD 98)

set(NO_TBB ${NO_TBB})

set(NO_SPINLOCK, ${NO_SPINLOCK})

set(WITH_THREAD_PROFILING ${WITH_THREAD_PROFILING})

set(POPCNT_CAPABILITY ${POPCNT_CAPABILITY})

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64 -g3 -Wall -msse2")

set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")

set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -funroll-loops")

set(INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")

set(CMAKE_EXPORT_COMPILE_COMMANDS on)

if (MINGW)

    option(BOWTIE_MM "Memory mapped files not supported on Windows" OFF)

    option(BOWTIE_SHARED_MEM "Shared memory not supported on Windows" OFF)

endif(MINGW)

if (APPLE)

    set(CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT "dwarf-with-dsym")

endif(APPLE)

set(BOWTIE2_BIN_LIST

    bowtie2-build-s

    bowtie2-build-l

    bowtie2-align-s

    bowtie2-align-l

    bowtie2-inspect-s

    bowtie2-inspect-l

    )

set(SHARED_CPPS

    ccnt_lut.cpp

    ref_read.cpp

    alphabet.cpp

    shmem.cpp

    edit.cpp

    bt2_idx.cpp

    bt2_io.cpp

    bt2_util.cpp

    reference.cpp

    ds.cpp

    multikey_qsort.cpp

    limit.cpp

    random_source.cpp

    )

set(SEARCH_CPPS

    qual.cpp pat.cpp sam.cpp

    read_qseq.cpp aligner_seed_policy.cpp 

    aligner_seed.cpp 

    aligner_seed2.cpp 

    aligner_sw.cpp 

    aligner_sw_driver.cpp aligner_cache.cpp 

    aligner_result.cpp ref_coord.cpp mask.cpp 

    pe.cpp aln_sink.cpp dp_framer.cpp 

    scoring.cpp presets.cpp unique.cpp 

    simple_func.cpp 

    random_util.cpp 

    aligner_bt.cpp sse_util.cpp 

    aligner_swsse.cpp outq.cpp 

    aligner_swsse_loc_i16.cpp 

    aligner_swsse_ee_i16.cpp 

    aligner_swsse_loc_u8.cpp 

    aligner_swsse_ee_u8.cpp 

    aligner_driver.cpp

    bowtie_main.cpp

    bt2_search.cpp

    )

set(BUILD_CPPS

    bt2_build.cpp

    diff_sample.cpp

    bowtie_build_main.cpp)

set(INSPECT_CPPS

    bt2_inspect.cpp 

    )

string(TIMESTAMP BUILD_DATE)

execute_process(COMMAND ${CMAKE_CXX_COMPILER} -v OUTPUT_VARIABLE COMPILER_VERSION)

add_definitions(

    -DBOWTIE2

    -DBUILD_HOST="${CMAKE_HOST_SYSTEM}"

    -DBUILD_TIME="${BUILD_DATE}"

    -DCOMPILER_VERSION="${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_VERSION}"

    -DBOWTIE2_VERSION="${PROJECT_VERSION}"

    -D_LARGEFILE_SOURCE

    -D_FILE_OFFSET_BITS=64

    -D_GNU_SOURCE

    )

if (WITH_AFFINITY)

    add_definitions(-DWITH_AFFINITY=1)

endif()

if (NO_SPINLOCK)

    add_definitions(-DNO_SPINLOCK)

endif()

if (POPCNT_CAPABILITY)

    add_definitions(-DPOPCNT_CAPABILITY)

    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I third_party")

endif()

if (WITH_THREAD_PROFILING)

    add_definitions(-DPER_THREAD_TIMING=1)

endif()

if (CMAKE_BUILD_TYPE STREQUAL "Release")

    add_definitions(-DNDEBUG)

endif()

find_package(Threads REQUIRED)

find_package(ZLIB REQUIRED)

find_path(TBB_INCLUDE_PATH tbb)

find_library(TBB_LIBRARY_PATH tbb)

find_library(TBB_MALLOC_LIBRARY_PATH tbbmalloc)

if (ZLIB_FOUND)

    link_libraries(${ZLIB_LIBRARIES})

    include_directories(${ZLIB_INCLUDE_DIRS})

endif()

if (Threads_FOUND)

    link_libraries(Threads::Threads)

endif()

if (NOT TBB_LIBRARY_PATH)

    set(SHARED_CPPS ${SHARED_CPPS} tinythread.cpp)

else()

    if (NOT NO_QUEUELOCK)

        add_definitions(-DWITH_TBB -DWITH_QUEUELOCK=1 -DNO_SPINLOCK)

    endif()

    include_directories(${TBB_INCLUDE_PATH})

    link_libraries(${TBB_LIBRARY_PATH} ${TBB_MALLOC_LIBRARY_PATH})

endif()

include_directories(${PROJECT_SOURCE_DIR})

get_directory_property(COMPILER_DEFS COMPILE_DEFINITIONS)

add_definitions(-DCOMPILER_OPTIONS="${CMAKE_CXX_FLAGS}")

add_executable(bowtie2-align-s ${SEARCH_CPPS} ${SHARED_CPPS})

add_executable(bowtie2-align-l ${SEARCH_CPPS} ${SHARED_CPPS})

add_executable(bowtie2-build-s ${BUILD_CPPS} ${SHARED_CPPS})

add_executable(bowtie2-build-l ${BUILD_CPPS} ${SHARED_CPPS})

add_executable(bowtie2-inspect-s ${INSPECT_CPPS} ${SHARED_CPPS})

add_executable(bowtie2-inspect-l ${INSPECT_CPPS} ${SHARED_CPPS})

set_target_properties(bowtie2-align-l bowtie2-build-l bowtie2-inspect-l PROPERTIES COMPILE_FLAGS "-DBOWTIE2_64BIT_INDEX")

set_target_properties(bowtie2-inspect-s bowtie2-inspect-l PROPERTIES COMPILE_FLAGS "-DBOWTIE_INSPECT_MAIN")

set_target_properties(${BOWTIE2_BIN_LIST} PROPERTIES DEBUG_POSTFIX "-debug")

add_test(NAME simple-align COMMAND ${PROJECT_SOURCE_DIR}/bowtie2 -x example/index/lambda_virus example/reads/longreads.fq)

INTRODUCTION

What is Bowtie 2?

Bowtie 2 is an ultrafast and memory-efficient tool for aligning

sequencing reads to long reference sequences. It is particularly good at

aligning reads of about 50 up to 100s or 1,000s of characters to

relatively long (e.g. mammalian) genomes. Bowtie 2 indexes the genome

with an FM Index (based on the Burrows-Wheeler Transform or BWT) to keep

its memory footprint small: for the human genome, its memory footprint

is typically around 3.2 gigabytes of RAM. Bowtie 2 supports gapped,

local, and paired-end alignment modes. Multiple processors can be used

simultaneously to achieve greater alignment speed. Cufflinks: a tool for

transcriptome assembly and isoform quantitiation from Bowtie 2 outputs

alignments in SAM format, enabling interoperation with a large number of

other tools (e.g. SAMtools, GATK) that use SAM. Bowtie 2 is distributed

under the GPLv3 license, and it runs on the command line under Windows,

Mac OS X and Linux.

aligning reads of about 50 up to 100s of characters to relatively long

(e.g. mammalian) genomes. Bowtie 2 indexes the genome with an FM Index

(based on the Burrows-Wheeler Transform or BWT) to keep its memory

footprint small: for the human genome, its memory footprint is typically

around 3.2 gigabytes of RAM. Bowtie 2 supports gapped, local, and

paired-end alignment modes. Multiple processors can be used

simultaneously to achieve greater alignment speed.

Bowtie 2 outputs alignments in SAM format, enabling interoperation with

a large number of other tools (e.g. SAMtools, GATK) that use SAM. Bowtie

2 is distributed under the GPLv3 license, and it runs on the command

line under Windows, Mac OS X and Linux.

Bowtie 2 is often the first step in pipelines for comparative genomics,

including for variation calling, ChIP-seq, RNA-seq, BS-seq. Bowtie 2 and

Bowtie (also called “Bowtie 1” here) are also tightly integrated into

some tools, including TopHat: a fast splice junction mapper for RNA-seq

reads, RNA-seq reads, Crossbow: a cloud-enabled software tool for

analyzing resequencing data, and Myrna: a cloud-enabled software tool

for aligning RNA-seq reads and measuring differential gene expression.

many other tools, some of which are listed here.

If you use Bowtie 2 for your published research, please cite our work.

Papers describing Bowtie 2 are:

If you use Bowtie 2 for your published research, please cite the Bowtie

paper. Thank you!

-   Langmead B, Wilks C, Antonescu V, Charles R. Scaling read aligners

    to hundreds of threads on general-purpose processors.

    _Bioinformatics_. 2018 Jul 18. doi: 10.1093/bioinformatics/bty648.

-   Langmead B, Salzberg SL. Fast gapped-read alignment with Bowtie 2.

    _Nature Methods_. 2012 Mar 4;9(4):357-9. doi: 10.1038/nmeth.1923.

How is Bowtie 2 different from Bowtie 1?

What isn’t Bowtie 2?

Bowtie 1 and Bowtie 2 are not general-purpose alignment tools like

MUMmer, BLAST or Vmatch. Bowtie 2 works best when aligning to large

genomes, though it supports arbitrarily small reference sequences

(e.g. amplicons). It handles very long reads (i.e. upwards of 10s or

100s of kilobases), but it is optimized for the read lengths and error

modes yielded by recent sequencers, such as the Illumina HiSeq 2000,

Roche 454, and Ion Torrent instruments.

If your goal is to align two very large sequences (e.g. two genomes),

consider using MUMmer. If your goal is very sensitive alignment to a

relatively short reference sequence (e.g. a bacterial genome), this can

be done with Bowtie 2 but you may want to consider using tools like

NUCmer, BLAT, or BLAST. These tools can be extremely slow when the

reference genome is long, but are often adequate when the reference is

short.

Bowtie 2 is geared toward aligning relatively short sequencing reads to

long genomes. That said, it handles arbitrarily small reference

sequences ( e.g. amplicons) and very long reads (i.e. upwards of 10s or

100s of kilobases), though it is slower in those settings. It is

optimized for the read lengths and error modes yielded by typical

Illumina sequencers.

Bowtie 2 does not support alignment of colorspace reads.

Bowtie 2 does not support alignment of colorspace reads. (Bowtie 1

does.)

What does it mean that some older Bowtie 2 versions are “beta”?

We said those Bowtie 2 versions were in “beta” to convey that it was not

as polished as a tool that had been around for a while, and was still in

flux. Since version 2.0.1, we declared Bowtie 2 was no longer “beta”.

OBTAINING BOWTIE 2

OBTAINING BOWTIE 2

Bowtie 2 is available from various package managers, notably Bioconda.

With Bioconda installed, you should be able to install Bowtie 2 with

conda install bowtie2.

Containerized versions of Bowtie 2 are also available via the

Biocontainers project (e.g. via Docker Hub).

Download Bowtie 2 sources and binaries from the Download section of the

Sourceforge site. Binaries are available for the Intel x86_64

You can also download Bowtie 2 sources and binaries from the Download

section of the Sourceforge site. Binaries are available for the x86_64

architecture running Linux, Mac OS X, and Windows. If you plan to

compile Bowtie 2 yourself, make sure to get the source package, i.e.,

the filename that ends in “-source.zip”.

Threading Building Blocks library (TBB) for this. If TBB is not

available on your system (e.g. make prints an error like

tbb/mutex.h: No such file or directory), you can install it yourself

(see Threading Building Blocks library) or build Bowtie 2 with

make NO_TBB=1 to use pthreads or Windows native multithreading instead.

from source (see Threading Building Blocks library) or install it using

your operating system’s preferred package manager. The table below list

some of the commands for a few of the more popular operating systems.

OS

Sync Package List

Search

Install

Ubuntu, Mint, Debian

    apt-get update

    apt-cache search tbb

    apt-get install libtbb-dev

Fedora, CentOS

    yum check-update

yum search tbb

    yum install tbb-devel.x86_64

Arch

    packman -Sy

    pacman -Ss tbb

    pacman -S extra/intel-tbb

Gentoo

    emerge --sync

    emerge --search tbb

    emerge dev-cpp/tbb

MacOS

    brew update

    brew search tbb

    brew install tbb

FreeBSD

    portsnap fetch update

    make search name=tbb

    cd /usr/ports/devel/tbb && make install && make clean

The Bowtie 2 Makefile also includes recipes for basic automatic

dependency management. Running make static-libs && make STATIC_BUILD=1

will issue a series of commands that will: 1. download TBB and zlib 2.

compile them as static libraries 3. link the resulting libraries to the

compiled Bowtie 2 binaries

If all fails Bowtie 2 can be built with make NO_TBB=1 to use pthreads or

Windows native multithreading instead.

Adding to PATH

Trim <int> bases from 3’ (right) end of each read before alignment

(default: 0).

    --trim-to [3:|5:]<int>

Trim reads exceeding <int> bases. Bases will be trimmed from either the

3’ (right) or 5’ (left) end of the read. If the read end if not

specified, bowtie 2 will default to trimming from the 3’ (right) end of

the read. --trim-to and -3/-5 are mutually exclusive.

    --phred33

Input qualities are ASCII chars equal to the Phred quality plus 33. This

    --soft-clipped-unmapped-tlen

Consider soft-clipped bases unmapped when calculating TLEN.

Consider soft-clipped bases unmapped when calculating TLEN. Only

available in --local mode.

    --sam-no-qname-trunc

 ! of this text document, or see the HTML manual online.

 ! -->

---

title: Bowtie 2 Manual

---

Introduction

============

What is Bowtie 2?

-----------------

[Bowtie 2] is an ultrafast and memory-efficient tool for aligning sequencing

reads to long reference sequences.  It is particularly good at aligning reads of

about 50 up to 100s or 1,000s of characters to relatively long (e.g. mammalian)

about 50 up to 100s of characters to relatively long (e.g. mammalian)

genomes.  Bowtie 2 indexes the genome with an [FM Index][FM Index Wiki] (based on the

[Burrows-Wheeler Transform] or [BWT]) to keep its memory footprint small: for

the human genome, its memory footprint is typically around 3.2 gigabytes of RAM.

 Bowtie 2 supports gapped, local, and paired-end alignment modes.  Multiple

processors can be used simultaneously to achieve greater alignment speed.

[Cufflinks][]: a tool for transcriptome assembly and isoform quantitiation from

Bowtie 2 outputs alignments in [SAM] format, enabling interoperation with a

large number of other tools (e.g. [SAMtools], [GATK]) that use SAM.  Bowtie 2 is

distributed under the [GPLv3 license], and it runs on the command line under

[Bowtie 2] is often the first step in pipelines for comparative genomics,

including for variation calling, ChIP-seq, RNA-seq, BS-seq.  [Bowtie 2] and

[Bowtie] (also called "[Bowtie 1]" here) are also tightly integrated into some

tools, including [TopHat]: a fast splice junction mapper for RNA-seq reads,

RNA-seq reads, [Crossbow]: a cloud-enabled software tool for analyzing

resequencing data, and [Myrna]: a cloud-enabled software tool for aligning

RNA-seq reads and measuring differential gene expression.

[Bowtie] (also called "[Bowtie 1]" here) are also tightly integrated into many

other tools, some of which [are listed here](http://bowtie-bio.sourceforge.net/bowtie2/other_tools.shtml).

If you use [Bowtie 2] for your published research, please cite our work.  Papers

describing Bowtie 2 are:

If you use [Bowtie 2] for your published research, please cite the [Bowtie

paper].  Thank you!

* Langmead B, Wilks C, Antonescu V, Charles R. [Scaling read aligners to hundreds

of threads on general-purpose processors](https://doi.org/10.1093/bioinformatics/bty648). _Bioinformatics_. 2018 Jul 18. doi:

10.1093/bioinformatics/bty648.

* Langmead B, Salzberg SL. [Fast gapped-read alignment with Bowtie 2](https://www.nature.com/articles/nmeth.1923). _Nature

Methods_. 2012 Mar 4;9(4):357-9. doi: 10.1038/nmeth.1923.

How is Bowtie 2 different from Bowtie 1?

What isn't Bowtie 2?

--------------------

Bowtie 1 and Bowtie 2 are not general-purpose alignment tools like [MUMmer],

[BLAST] or [Vmatch].  Bowtie 2 works best when aligning to large genomes, though

it supports arbitrarily small reference sequences (e.g. amplicons).  It handles

very long reads (i.e. upwards of 10s or 100s of kilobases), but it is optimized

for the read lengths and error modes yielded by recent sequencers, such as the

Illumina HiSeq 2000, Roche 454, and Ion Torrent instruments.

If your goal is to align two very large sequences (e.g. two genomes), consider

using [MUMmer].  If your goal is very sensitive alignment to a relatively short

reference sequence (e.g. a bacterial genome), this can be done with Bowtie 2 but

you may want to consider using tools like [NUCmer], [BLAT], or [BLAST].  These

tools can be extremely slow when the reference genome is long, but are often

adequate when the reference is short.

Bowtie 2 does not support alignment of colorspace reads.

Bowtie 2 is geared toward aligning relatively short sequencing reads to long

genomes.  That said, it handles arbitrarily small reference sequences (e.g.

amplicons) and very long reads (i.e. upwards of 10s or 100s of kilobases),

though it is slower in those settings.  It is optimized for the read lengths

and error modes yielded by typical Illumina sequencers.

What does it mean that some older Bowtie 2 versions are "beta"?

--------------------------------------------------------------

Bowtie 2 does not support alignment of colorspace reads.  (Bowtie 1 does.)

We said those Bowtie 2 versions were in "beta" to convey that it was not as

polished as a tool that had been around for a while, and was still in flux.

Since version 2.0.1, we declared Bowtie 2 was no longer "beta".

Obtaining Bowtie 2

==================

Download Bowtie 2 sources and binaries from the [Download] section of the

Sourceforge site.  Binaries are available for the Intel `x86_64` architecture

Bowtie 2 is available from various package managers, notably [Bioconda](https://anaconda.org/bioconda/bowtie2).

With Bioconda installed, you should be able to install Bowtie 2 with `conda

install bowtie2`.

Containerized versions of Bowtie 2 are also available via the [Biocontainers](https://BioContainers.pro)

project (e.g. [via Docker Hub](https://hub.docker.com/r/biocontainers/bowtie2/)).

You can also download Bowtie 2 sources and binaries from the [Download] section

of the Sourceforge site.  Binaries are available for the `x86_64` architecture

running Linux, Mac OS X, and Windows.  If you plan to compile Bowtie 2 yourself,

make sure to get the source package, i.e., the filename that ends in

"-source.zip".

Bowtie 2 can be run on many threads. By default, Bowtie 2 uses the Threading

Building Blocks library (TBB) for this. If TBB is not available on your system

(e.g. `make` prints an error like `tbb/mutex.h: No such file or directory`),

you can install it yourself (see [Threading Building Blocks library]) or build

Bowtie 2 with `make NO_TBB=1` to use pthreads or Windows native multithreading

instead.

you can install it yourself from source (see [Threading Building Blocks library])

or install it using your operating system's preferred package manager.

The table below list some of the commands for a few of the more popular

operating systems.

<table>

<tr><th>OS</th><th>Sync Package List</th><th>Search</th><th>Install</th></tr>

<tr><td>Ubuntu, Mint, Debian</td>

<td>

    apt-get update

</td>

<td>

    apt-cache search tbb

</td>

<td>

    apt-get install libtbb-dev

</td></tr>

<tr><td>Fedora, CentOS</td>

<td>

    yum check-update

</td>

<td>

    yum search tbb

</td>

<td>

    yum install tbb-devel.x86_64

</td></tr>

<tr><td>Arch</td>

<td>

    packman -Sy

</td>

<td>

    pacman -Ss tbb

</td>

<td>

    pacman -S extra/intel-tbb

</td></tr>

<tr><td>Gentoo</td>

<td>

    emerge --sync

</td>

<td>

    emerge --search tbb

</td>

<td>

    emerge dev-cpp/tbb

</td>

<tr><td>MacOS</td>

<td>

    brew update

</td>

<td>

    brew search tbb

</td>

<td>

    brew install tbb

</td></tr>

<tr><td>FreeBSD</td>

<td>

    portsnap fetch update

</td>

<td>

    make search name=tbb

</td>

<td>

    cd /usr/ports/devel/tbb && make install && make clean

</table>

The Bowtie 2 Makefile also includes recipes for basic automatic dependency

management. Running `make static-libs && make STATIC_BUILD=1` will issue

a series of commands that will:

  1. download TBB and zlib

  2. compile them as static libraries

  3. link the resulting libraries to the compiled Bowtie 2 binaries

If all fails Bowtie 2 can be built with `make NO_TBB=1` to use pthreads

or Windows native multithreading instead.

Adding to PATH

--------------

Trim `<int>` bases from 3' (right) end of each read before alignment (default: 0).

</td></tr><tr><td id="bowtie2-options-trim-to">

    --trim-to [3:|5:]<int>

</td><td>

Trim reads exceeding `<int>` bases. Bases will be trimmed from either the 3' (right)

or 5' (left) end of the read. If the read end if not specified, bowtie 2 will default

to trimming from the 3' (right) end of the read. [`--trim-to`] and [`-3`]/[`-5`] are

mutually exclusive.

</td></tr><tr><td id="bowtie2-options-phred33-quals">

    --phred33

in those fields instead.

</td></tr>

<tr><td id="bowtie2-options-soft-clipped-unmapped-tlen-sec-seq">

<tr><td id="bowtie2-options-soft-clipped-unmapped-tlen">

    --soft-clipped-unmapped-tlen

</td><td>

Consider soft-clipped bases unmapped when calculating `TLEN`.

Consider soft-clipped bases unmapped when calculating `TLEN`. Only available

in [`--local`] mode.

</td></tr>

<tr><td id="bowtie2-options-sam-no-qname-trunc">

[Threading Building Blocks library]:                  https://www.threadingbuildingblocks.org

[TopHat]:                                             http://tophat.cbcb.umd.edu/

[UCSC]:                                               http://genome.ucsc.edu/cgi-bin/hgGateway

[Vmatch]:                                             http://www.vmatch.de/

[Xcode]:                                              http://developer.apple.com/xcode/

[`+I`/`--minins`]:                                    #bowtie2-options-I

[`+I`]:                                               #bowtie2-options-I

[`-3`]:                                               #bowtie2-options-3

[`-5`/`--trim5`]:                                     #bowtie2-options-5

[`-5`]:                                               #bowtie2-options-5

[`--trim-to`]:                                        #bowtie2-options-trim-to

[`-D`]:                                               #bowtie2-options-D

[`-L`]:                                               #bowtie2-options-L

[`-N`]:                                               #bowtie2-options-N

Version Release History

=======================

Version 2.3.4.2 - Aug 7, 2018

    * Fixed issue causing `bowtie2` to fail in `--fast-local` mode.

    * Fixed issue causing `--soft-clipped-unmapped-tlen` to be a positional argument.

    * New option `--trim-to N` causes `bowtie2` to trim reads longer

      than `N` bases to exactly `N` bases.  Can trim from either 3'

      or 5' end, e.g. `--trim-to 5:30` trims reads to 30 bases,

      truncating at the 5' end.

    * Updated "Building from source" manual section with additional

      instructions on installing TBB.

    * Several other updates to manual, including new mentions of

      [Bioconda](http://bioconda.github.io) and

      [Biocontainers](https://biocontainers.pro).

    * Fixed an issue preventing `bowtie2` from processing more than

      one pattern source when running single threaded.

    * Fixed an issue causing `bowtie2` and `bowtie2-inspect` to crash if

      the index contains a gap-only segment.

    * Added experimental BAM input mode `-b`. Works only with unpaired

      input reads and BAM files that are sorted by read name (`samtools

      sort -n`). BAM input mode also supports the following options:

        o `--preserve-sam-tags`: Preserve any optional fields present in BAM record

        o `--align-paired-reads`: Paired-end mode for BAM files

    * Added experimental cmake support

Thread-scaling paper appears - July 19, 2018

    * Our latest work on Bowtie's core thread scaling capabilities

      [just appeared Open Access in the journal Bioinformatics](href="https://academic.oup.com/bioinformatics/advance-article/doi/10.1093/bioinformatics/bty648/5055585)

Version 2.3.4.1 - Feb 3, 2018

    * Fixed an issue with `--reorder` that caused bowtie2 to crash