minimap2 0.2.22.0 → 0.2.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ceb411a88448c6ed13e6d842450264e91569260c9b19d77e699a93736768522
-  data.tar.gz: 76c1f3466375b73c54db6cd2574ffe19a817b11994d50e9e8473a209566b14f5
+  metadata.gz: 1bbe7130374c248e008183b82ffa9feb7af9738184d654c8a14c7963b96f5c09
+  data.tar.gz: ddae428827a8e1f8e7c9cc8684f44aa266ec1d73d32e8d6a65e64a459d509292
 SHA512:
-  metadata.gz: 05a313f05984e2afab772da3971249327a9461a92d8b1fbcf53329ea5cd9d421e4ab8a137bd16213b86d6912bf1d43fd7f22c1bb5408a36004a64296fab294d9
-  data.tar.gz: 7739312455aba2b14192eef634623f351fc4cea721d142b815ce41d651bc3de84e0fe413de6d24e8551ed90a2d71bcbf82a3df5b87685cb1474e6a134ed9fefe
+  metadata.gz: 8f1caa66a874a45f4df9b0971f55cb0f436351c62f6d2bb4ba07e2d8cfe1485e391e58c952cdcaa5f256a9fa9e26376b865cd919ff53d374ea32666ae486de24
+  data.tar.gz: bef5486385f7a52d37566a866776791eec9eda5bf1d707e253f7845f5f87689c4258076874dcff44852f09b39d51522ab2ecf8ebbbe675b2ce98c2f87b60df76

data/README.md

@@ -6,85 +6,61 @@
 [![Docs Latest](https://img.shields.io/badge/docs-stable-blue.svg)](https://rubydoc.info/gems/minimap2)
 [![DOI](https://zenodo.org/badge/325711305.svg)](https://zenodo.org/badge/latestdoi/325711305)
 
-
-
 :dna: [minimap2](https://github.com/lh3/minimap2) - the long-read mapper - for [Ruby](https://github.com/ruby/ruby)
 
 ## Installation
 
-Open your terminal and type the following commands in order. You need to build minimap2 on your own because you need to create a shared library that contains cmappy functions.
-
-Build
-
-```sh
-git clone --recursive https://github.com/kojix2/ruby-minimap2
-cd ruby-minimap2
-bundle install
-bundle exec rake minimap2:build
-```
-
-Install
-
 ```
-bundle exec rake install
+gem install minimap2
 ```
 
-Ruby-minimap2 is [tested on Ubuntu and macOS](https://github.com/kojix2/ruby-minimap2/actions). 
+<details>
+<summary><b>Compiling from source</b></summary>
+
+    git clone --recursive https://github.com/kojix2/ruby-minimap2
+    cd ruby-minimap2
+    bundle install
+    bundle exec rake minimap2:build
+    bundle exec rake install
+ 
+</details>
 
 ## Quick Start
 
 ```ruby
 require "minimap2"
-```
-
-Create aligner
-
-```ruby
-aligner = Minimap2::Aligner.new("minimap2/test/MT-human.fa")
-```
-
-Retrieve a subsequence from the index
-
-```ruby
-seq = aligner.seq("MT_human", 100, 200)
-```
-
-Mapping
-
-```ruby
-hits = aligner.align(seq)
-pp hits[0]
-```
 
-```
-=> 
-#<Minimap2::Alignment:0x000055fe18223f50
- @blen=100,
- @cigar=[[100, 0]],
- @cigar_str="100M",
- @cs="",
- @ctg="MT_human",
- @ctg_len=16569,
- @mapq=60,
- @md="",
- @mlen=100,
- @nm=0,
- @primary=1,
- @q_en=100,
- @q_st=0,
- @r_en=200,
- @r_st=100,
- @read_num=1,
- @strand=1,
- @trans_strand=0>
-```
+aligner = Minimap2::Aligner.new("ext/minimap2/test/MT-human.fa")
+seq     = aligner.seq("MT_human", 100, 200)
+hits    = aligner.align(seq)
+pp hits
+```
+```
+[#<Minimap2::Alignment:0x000055bbfde2d128
+  @blen=100,
+  @cigar=[[100, 0]],
+  @cigar_str="100M",
+  @cs="",
+  @ctg="MT_human",
+  @ctg_len=16569,
+  @mapq=60,
+  @md="",
+  @mlen=100,
+  @nm=0,
+  @primary=1,
+  @q_en=100,
+  @q_st=0,
+  @r_en=200,
+  @r_st=100,
+  @read_num=1,
+  @strand=1,
+  @trans_strand=0>]
+```
+ 
+</details>
 
 ## APIs Overview
 
-API is based on [Mappy](https://github.com/lh3/minimap2/tree/master/python), the official Python binding for Minimap2. 
-
-Note: `Aligner#map` has been changed to `aligne`, because `map` means iterator in Ruby.
-
 ```markdown
 * Minimap2 module
   - fastx_read                  Read fasta/fastq file.
@@ -129,11 +105,19 @@ Note: `Aligner#map` has been changed to `aligne`, because `map` means iterator i
     * MapOpt class              Mapping options.
 ```
 
-This is not all. See the [RubyDoc.info documentation](https://rubydoc.info/gems/minimap2/) for more details.
+* API is based on [Mappy](https://github.com/lh3/minimap2/tree/master/python), the official Python binding for Minimap2. 
+* `Aligner#map` has been changed to `align`, because `map` means iterator in Ruby.
+* See [RubyDoc](https://rubydoc.info/gems/minimap2/) for details.
 
-ruby-minimap2 is built on top of [Ruby-FFI](https://github.com/ffi/ffi). 
-Native functions can be called from the FFI module. FFI also provides the way to access some C structs.
+<details>
+<summary><b>C Structures and Functions</b></summary>
 
+### FFI
+* Ruby-Minimap2 is built on top of [Ruby-FFI](https://github.com/ffi/ffi). 
+  * Native C functions can be called from the `Minimap2::FFI` module. 
+  * Native C structure members can be accessed.
+  * Bitfields are supported by [ffi-bitfield](https://github.com/kojix2/ffi-bitfield) gems.
+ 
 ```ruby
 aligner.idx_opt.members
 # => [:k, :w, :flag, :bucket_bits, :mini_batch_size, :batch_size]
@@ -145,10 +129,15 @@ aligner.idx_opt[:k] = 14
 aligner.idx_opt[:k]
 # => 14
 ```
+ 
+</details>
+
+## Contributing
 
-## Development
+<details>
+<summary><b>Development</b></summary>
 
-Fork your repository.
+ Fork your repository.
 then clone.
 
 ```sh
@@ -179,16 +168,11 @@ Run tests.
 bundle exec rake test
 ```
 
-## Contributing
+</details>
 
-ruby-minimap2 is a library under development and there are many points to be improved. Please feel free to send us your pull request. 
+ruby-minimap2 is a library under development and there are many points to be improved.
 
-* [Report bugs](https://github.com/kojix2/ruby-minimap2/issues)
-* Fix bugs and [submit pull requests](https://github.com/kojix2/ruby-minimap2/pulls)
-* Write, clarify, or fix documentation
-* Suggest or add new features
-* Create tools based on ruby-minimap2
-* Update minimap2 in github submodule
+Please feel free to report [bugs](https://github.com/kojix2/ruby-minimap2/issues) and [pull requests](https://github.com/kojix2/ruby-minimap2/pulls)!
 
 ## License
 

data/ext/Rakefile

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "rake"
+require "fileutils"
+require "ffi"
+
+minimap2_dir = File.expand_path("minimap2", __dir__)
+target_dir = "../../vendor"
+target_fname = FFI.map_library_name("minimap2")
+target_path = File.join(target_dir, target_fname)
+
+task default: ["minimap2:build", "minimap2:clean"]
+
+namespace :minimap2 do
+  desc "Compile Minimap2"
+  task :build do
+    Dir.chdir(minimap2_dir) do
+      # Add -fPIC option to Makefile
+      sh "git apply ../minimap2.patch"
+      sh "cp ../cmappy/cmappy.h ../cmappy/cmappy.c ."
+      sh "make"
+      case RbConfig::CONFIG["host_os"]
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        sh "cc *.o -shared -o #{target_fname} -lm -lz -lpthread"
+      when /darwin|mac os/
+        sh "clang -dynamiclib -undefined dynamic_lookup -o #{target_fname} *.o -lm -lz -lpthread"
+        sh "otool -L #{target_fname}"
+      else
+        sh "cc *.o -shared -o #{target_fname} -lm -lz -lpthread"
+        sh "ldd -r #{target_fname}"
+      end
+      sh "rm cmappy.h cmappy.c"
+      sh "git apply -R ../minimap2.patch"
+      FileUtils.mkdir_p(target_dir)
+      warn "mkdir -p #{target_dir}"
+      sh "mv #{target_fname} #{target_path}"
+    end
+  end
+
+  desc "Clean"
+  task :clean do
+    Dir.chdir(minimap2_dir) do
+      sh "make clean"
+    end
+  end
+
+  task cleanall: [:clean]
+
+  desc "Clean all"
+  task :cleanall do
+    Dir.chdir(minimap2_dir) do
+      sh "rm #{target_path}" if File.exist?(target_path)
+    end
+  end
+end

data/ext/cmappy/cmappy.c

@@ -0,0 +1,129 @@
+#include "cmappy.h"
+
+void mm_reg2hitpy(const mm_idx_t *mi, mm_reg1_t *r, mm_hitpy_t *h)
+{
+	h->ctg = mi->seq[r->rid].name;
+	h->ctg_len = mi->seq[r->rid].len;
+	h->ctg_start = r->rs, h->ctg_end = r->re;
+	h->qry_start = r->qs, h->qry_end = r->qe;
+	h->strand = r->rev? -1 : 1;
+	h->mapq = r->mapq;
+	h->mlen = r->mlen;
+	h->blen = r->blen;
+	h->NM = r->blen - r->mlen + r->p->n_ambi;
+	h->trans_strand = r->p->trans_strand == 1? 1 : r->p->trans_strand == 2? -1 : 0;
+	h->is_primary = (r->id == r->parent);
+	h->seg_id = r->seg_id;
+	h->n_cigar32 = r->p->n_cigar;
+	h->cigar32 = r->p->cigar;
+}
+
+void mm_free_reg1(mm_reg1_t *r)
+{
+	free(r->p);
+}
+
+kseq_t *mm_fastx_open(const char *fn)
+{
+	gzFile fp;
+	fp = fn && strcmp(fn, "-") != 0? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
+	return kseq_init(fp);
+}
+
+void mm_fastx_close(kseq_t *ks)
+{
+	gzFile fp;
+	fp = ks->f->f;
+	kseq_destroy(ks);
+	gzclose(fp);
+}
+
+int mm_verbose_level(int v)
+{
+	if (v >= 0) mm_verbose = v;
+	return mm_verbose;
+}
+
+void mm_reset_timer(void)
+{
+	extern double realtime(void);
+	mm_realtime0 = realtime();
+}
+
+mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
+{
+	mm_reg1_t *r;
+
+	// Py_BEGIN_ALLOW_THREADS
+	if (seq2 == 0) {
+		r = mm_map(mi, strlen(seq1), seq1, n_regs, b, opt, NULL);
+	} else {
+		int _n_regs[2];
+		mm_reg1_t *regs[2];
+		char *seq[2];
+		int i, len[2];
+
+		len[0] = strlen(seq1);
+		len[1] = strlen(seq2);
+		seq[0] = (char*)seq1;
+		seq[1] = strdup(seq2);
+		for (i = 0; i < len[1]>>1; ++i) {
+			int t = seq[1][len[1] - i - 1];
+			seq[1][len[1] - i - 1] = seq_comp_table[(uint8_t)seq[1][i]];
+			seq[1][i] = seq_comp_table[t];
+		}
+		if (len[1]&1) seq[1][len[1]>>1] = seq_comp_table[(uint8_t)seq[1][len[1]>>1]];
+		mm_map_frag(mi, 2, len, (const char**)seq, _n_regs, regs, b, opt, NULL);
+		for (i = 0; i < _n_regs[1]; ++i)
+			regs[1][i].rev = !regs[1][i].rev;
+		*n_regs = _n_regs[0] + _n_regs[1];
+		regs[0] = (mm_reg1_t*)realloc(regs[0], sizeof(mm_reg1_t) * (*n_regs));
+		memcpy(&regs[0][_n_regs[0]], regs[1], _n_regs[1] * sizeof(mm_reg1_t));
+		free(regs[1]);
+		r = regs[0];
+	}
+	// Py_END_ALLOW_THREADS
+
+	return r;
+}
+
+char *mappy_revcomp(int len, const uint8_t *seq)
+{
+	int i;
+	char *rev;
+	rev = (char*)malloc(len + 1);
+	for (i = 0; i < len; ++i)
+		rev[len - i - 1] = seq_comp_table[seq[i]];
+	rev[len] = 0;
+	return rev;
+}
+
+char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int *len)
+{
+	int i, rid;
+	char *s;
+	*len = 0;
+	rid = mm_idx_name2id(mi, name);
+	if (rid < 0) return 0;
+	if ((uint32_t)st >= mi->seq[rid].len || st >= en) return 0;
+	if (en < 0 || (uint32_t)en > mi->seq[rid].len)
+		en = mi->seq[rid].len;
+	s = (char*)malloc(en - st + 1);
+	*len = mm_idx_getseq(mi, rid, st, en, (uint8_t*)s);
+	for (i = 0; i < *len; ++i)
+		s[i] = "ACGTN"[(uint8_t)s[i]];
+	s[*len] = 0;
+	return s;
+}
+
+mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int len)
+{
+	const char *fake_name = "N/A";
+	char *s;
+	mm_idx_t *mi;
+	s = (char*)calloc(len + 1, 1);
+	memcpy(s, seq, len);
+	mi = mm_idx_str(w, k, is_hpc, bucket_bits, 1, (const char**)&s, (const char**)&fake_name);
+	free(s);
+	return mi;
+}

data/ext/cmappy/cmappy.h

@@ -0,0 +1,44 @@
+#ifndef CMAPPY_H
+#define CMAPPY_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+#include "minimap.h"
+#include "kseq.h"
+KSEQ_DECLARE(gzFile)
+
+typedef struct {
+	const char *ctg;
+	int32_t ctg_start, ctg_end;
+	int32_t qry_start, qry_end;
+	int32_t blen, mlen, NM, ctg_len;
+	uint8_t mapq, is_primary;
+	int8_t strand, trans_strand;
+	int32_t seg_id;
+	int32_t n_cigar32;
+	uint32_t *cigar32;
+} mm_hitpy_t;
+
+void mm_reg2hitpy(const mm_idx_t *mi, mm_reg1_t *r, mm_hitpy_t *h);
+
+void mm_free_reg1(mm_reg1_t *r);
+
+kseq_t *mm_fastx_open(const char *fn);
+
+void mm_fastx_close(kseq_t *ks);
+
+int mm_verbose_level(int v);
+
+void mm_reset_timer(void);
+
+extern unsigned char seq_comp_table[256];
+mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt);
+
+char *mappy_revcomp(int len, const uint8_t *seq);
+
+char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int *len);
+
+mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int len);
+
+#endif

data/ext/minimap2/FAQ.md

@@ -0,0 +1,46 @@
+#### 1. Alignment different with option `-a` or `-c`?
+
+Without `-a`, `-c` or `--cs`, minimap2 only finds *approximate* mapping
+locations without detailed base alignment. In particular, the start and end
+positions of the alignment are impricise. With one of those options, minimap2
+will perform base alignment, which is generally more accurate but is much
+slower.
+
+#### 2. How to map Illumina short reads to noisy long reads?
+
+No good solutions. The better approach is to assemble short reads into contigs
+and then map noisy reads to contigs.
+
+#### 3. The output SAM doesn't have a header.
+
+By default, minimap2 indexes 4 billion reference bases (4Gb) in a batch and map
+all reads against each reference batch. Given a reference longer than 4Gb,
+minimap2 is unable to see all the sequences and thus can't produce a correct
+SAM header. In this case, minimap2 doesn't output any SAM header. There are two
+solutions to this issue. First, you may increase option `-I` to, for example,
+`-I8g` to index more reference bases in a batch. This is preferred if your
+machine has enough memory. Second, if your machines doesn't have enough memory
+to hold the reference index, you can use the `--split-prefix` option in a
+command line like:
+```sh
+minimap2 -ax map-ont --split-prefix=tmp ref.fa reads.fq
+```
+This second approach uses less memory, but it is slower and requires temporary
+disk space.
+
+#### 4. The output SAM is malformatted.
+
+This typically happens when you use nohup to wrap a minimap2 command line.
+Nohup is discouraged as it breaks piping. If you have to use nohup, please
+specify an output file with option `-o`.
+
+#### 5. How to output one alignment per read?
+
+You can use `--secondary=no` to suppress secondary alignments (aka multiple
+mappings), but you can't suppress supplementary alignment (aka split or
+chimeric alignment) this way. You can use samtools to filter out these
+alignments:
+```sh
+minimap2 -ax map-out ref.fa reads.fq | samtools view -F0x900
+```
+However, this is discouraged as supplementary alignment is informative.

data/ext/minimap2/LICENSE.txt

@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2018-     Dana-Farber Cancer Institute
+              2017-2018 Broad Institute, Inc.
+
+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.

data/ext/minimap2/MANIFEST.in

@@ -0,0 +1,10 @@
+include *.h
+include Makefile
+include ksw2_dispatch.c
+include main.c
+include README.md
+include sse2neon/emmintrin.h
+include python/cmappy.h
+include python/cmappy.pxd
+include python/mappy.pyx
+include python/README.rst

data/ext/minimap2/Makefile

@@ -0,0 +1,132 @@
+CFLAGS=		-g -Wall -O2 -Wc++-compat #-Wextra
+CPPFLAGS=	-DHAVE_KALLOC
+INCLUDES=
+OBJS=		kthread.o kalloc.o misc.o bseq.o sketch.o sdust.o options.o index.o \
+			lchain.o align.o hit.o seed.o map.o format.o pe.o esterr.o splitidx.o \
+			ksw2_ll_sse.o
+PROG=		minimap2
+PROG_EXTRA=	sdust minimap2-lite
+LIBS=		-lm -lz -lpthread
+
+ifeq ($(arm_neon),) # if arm_neon is not defined
+ifeq ($(sse2only),) # if sse2only is not defined
+	OBJS+=ksw2_extz2_sse41.o ksw2_extd2_sse41.o ksw2_exts2_sse41.o ksw2_extz2_sse2.o ksw2_extd2_sse2.o ksw2_exts2_sse2.o ksw2_dispatch.o
+else                # if sse2only is defined
+	OBJS+=ksw2_extz2_sse.o ksw2_extd2_sse.o ksw2_exts2_sse.o
+endif
+else				# if arm_neon is defined
+	OBJS+=ksw2_extz2_neon.o ksw2_extd2_neon.o ksw2_exts2_neon.o
+    INCLUDES+=-Isse2neon
+ifeq ($(aarch64),)	#if aarch64 is not defined
+	CFLAGS+=-D_FILE_OFFSET_BITS=64 -mfpu=neon -fsigned-char
+else				#if aarch64 is defined
+	CFLAGS+=-D_FILE_OFFSET_BITS=64 -fsigned-char
+endif
+endif
+
+ifneq ($(asan),)
+	CFLAGS+=-fsanitize=address
+	LIBS+=-fsanitize=address
+endif
+
+ifneq ($(tsan),)
+	CFLAGS+=-fsanitize=thread
+	LIBS+=-fsanitize=thread
+endif
+
+.PHONY:all extra clean depend
+.SUFFIXES:.c .o
+
+.c.o:
+		$(CC) -c $(CFLAGS) $(CPPFLAGS) $(INCLUDES) $< -o $@
+
+all:$(PROG)
+
+extra:all $(PROG_EXTRA)
+
+minimap2:main.o libminimap2.a
+		$(CC) $(CFLAGS) main.o -o $@ -L. -lminimap2 $(LIBS)
+
+minimap2-lite:example.o libminimap2.a
+		$(CC) $(CFLAGS) $< -o $@ -L. -lminimap2 $(LIBS)
+
+libminimap2.a:$(OBJS)
+		$(AR) -csru $@ $(OBJS)
+
+sdust:sdust.c kalloc.o kalloc.h kdq.h kvec.h kseq.h ketopt.h sdust.h
+		$(CC) -D_SDUST_MAIN $(CFLAGS) $< kalloc.o -o $@ -lz
+
+# SSE-specific targets on x86/x86_64
+
+ifeq ($(arm_neon),)   # if arm_neon is defined, compile this target with the default setting (i.e. no -msse2)
+ksw2_ll_sse.o:ksw2_ll_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse2 $(CPPFLAGS) $(INCLUDES) $< -o $@
+endif
+
+ksw2_extz2_sse41.o:ksw2_extz2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH $(INCLUDES) $< -o $@
+
+ksw2_extz2_sse2.o:ksw2_extz2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse2 -mno-sse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH -DKSW_SSE2_ONLY $(INCLUDES) $< -o $@
+
+ksw2_extd2_sse41.o:ksw2_extd2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH $(INCLUDES) $< -o $@
+
+ksw2_extd2_sse2.o:ksw2_extd2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse2 -mno-sse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH -DKSW_SSE2_ONLY $(INCLUDES) $< -o $@
+
+ksw2_exts2_sse41.o:ksw2_exts2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH $(INCLUDES) $< -o $@
+
+ksw2_exts2_sse2.o:ksw2_exts2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) -msse2 -mno-sse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH -DKSW_SSE2_ONLY $(INCLUDES) $< -o $@
+
+ksw2_dispatch.o:ksw2_dispatch.c ksw2.h
+		$(CC) -c $(CFLAGS) -msse4.1 $(CPPFLAGS) -DKSW_CPU_DISPATCH $(INCLUDES) $< -o $@
+
+# NEON-specific targets on ARM
+
+ksw2_extz2_neon.o:ksw2_extz2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) $(CPPFLAGS) -DKSW_SSE2_ONLY -D__SSE2__ $(INCLUDES) $< -o $@
+
+ksw2_extd2_neon.o:ksw2_extd2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) $(CPPFLAGS) -DKSW_SSE2_ONLY -D__SSE2__ $(INCLUDES) $< -o $@
+
+ksw2_exts2_neon.o:ksw2_exts2_sse.c ksw2.h kalloc.h
+		$(CC) -c $(CFLAGS) $(CPPFLAGS) -DKSW_SSE2_ONLY -D__SSE2__ $(INCLUDES) $< -o $@
+
+# other non-file targets
+
+clean:
+		rm -fr gmon.out *.o a.out $(PROG) $(PROG_EXTRA) *~ *.a *.dSYM build dist mappy*.so mappy.c python/mappy.c mappy.egg*
+
+depend:
+		(LC_ALL=C; export LC_ALL; makedepend -Y -- $(CFLAGS) $(CPPFLAGS) -- *.c)
+
+# DO NOT DELETE
+
+align.o: minimap.h mmpriv.h bseq.h kseq.h ksw2.h kalloc.h
+bseq.o: bseq.h kvec.h kalloc.h kseq.h
+esterr.o: mmpriv.h minimap.h bseq.h kseq.h
+example.o: minimap.h kseq.h
+format.o: kalloc.h mmpriv.h minimap.h bseq.h kseq.h
+hit.o: mmpriv.h minimap.h bseq.h kseq.h kalloc.h khash.h
+index.o: kthread.h bseq.h minimap.h mmpriv.h kseq.h kvec.h kalloc.h khash.h
+index.o: ksort.h
+kalloc.o: kalloc.h
+ksw2_extd2_sse.o: ksw2.h kalloc.h
+ksw2_exts2_sse.o: ksw2.h kalloc.h
+ksw2_extz2_sse.o: ksw2.h kalloc.h
+ksw2_ll_sse.o: ksw2.h kalloc.h
+kthread.o: kthread.h
+lchain.o: mmpriv.h minimap.h bseq.h kseq.h kalloc.h krmq.h
+main.o: bseq.h minimap.h mmpriv.h kseq.h ketopt.h
+map.o: kthread.h kvec.h kalloc.h sdust.h mmpriv.h minimap.h bseq.h kseq.h
+map.o: khash.h ksort.h
+misc.o: mmpriv.h minimap.h bseq.h kseq.h ksort.h
+options.o: mmpriv.h minimap.h bseq.h kseq.h
+pe.o: mmpriv.h minimap.h bseq.h kseq.h kvec.h kalloc.h ksort.h
+sdust.o: kalloc.h kdq.h kvec.h sdust.h
+seed.o: mmpriv.h minimap.h bseq.h kseq.h kalloc.h ksort.h
+sketch.o: kvec.h kalloc.h mmpriv.h minimap.h bseq.h kseq.h
+splitidx.o: mmpriv.h minimap.h bseq.h kseq.h