minimap2 0.2.25.0 → 0.2.25.1

data/ext/minimap2/lib/simde/test/x86/test-avx.h

@@ -0,0 +1,16 @@
+#include "../../simde/x86/avx.h"
+
+#include "test-sse2.h"
+
+#if !defined(SIMDE_TEST_X86_AVX)
+#define SIMDE_TEST_X86_AVX
+
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m256, f32)
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m256d, f64)
+
+#define simde_assert_m256_close(a, b, precision) \
+  simde_assert_m256_f32_close_ex(__LINE__, __FILE__, a, b, precision)
+#define simde_assert_m256d_close(a, b, precision) \
+  simde_assert_m256d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
+
+#endif /* !defined(SIMDE_TEST_X86_AVX) */

data/ext/minimap2/lib/simde/test/x86/test-avx512.h

@@ -0,0 +1,25 @@
+#include "../../simde/x86/avx512f.h"
+
+#include "test-avx.h"
+
+#if !defined(SIMDE_TEST_X86_AVX512)
+#define SIMDE_TEST_X86_AVX512
+
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m512, f32)
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m512d, f64)
+
+#define simde_assert_m512_close(a, b, precision) \
+  simde_assert_m512_f32_close_ex(__LINE__, __FILE__, a, b, precision)
+#define simde_assert_m512d_close(a, b, precision) \
+  simde_assert_m512d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
+
+#define simde_assert_mmask8(a, op, b) \
+  munit_assert_uint8(HEDLEY_STATIC_CAST(uint8_t, a), op, HEDLEY_STATIC_CAST(uint8_t, b))
+#define simde_assert_mmask16(a, op, b) \
+  munit_assert_uint16(HEDLEY_STATIC_CAST(uint16_t, a), op, HEDLEY_STATIC_CAST(uint16_t, b))
+#define simde_assert_mmask32(a, op, b) \
+  munit_assert_uint32(HEDLEY_STATIC_CAST(uint32_t, a), op, HEDLEY_STATIC_CAST(uint32_t, b))
+#define simde_assert_mmask64(a, op, b) \
+  munit_assert_uint64(HEDLEY_STATIC_CAST(uint64_t, a), op, HEDLEY_STATIC_CAST(uint64_t, b))
+
+#endif /* !defined(SIMDE_TEST_X86_AVX512) */

data/ext/minimap2/lib/simde/test/x86/test-mmx.h

@@ -0,0 +1,13 @@
+#include "../../simde/x86/mmx.h"
+
+#include "test-x86-internal.h"
+
+#if !defined(SIMDE_TEST_X86_MMX)
+#define SIMDE_TEST_X86_MMX
+
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m64, f32)
+
+#define simde_assert_m64_close(a, b, precision) \
+  simde_assert_m64_f32_close_ex(__LINE__, __FILE__, a, b, precision)
+
+#endif /* !defined(SIMDE_TEST_X86_MMX) */

data/ext/minimap2/lib/simde/test/x86/test-sse.h

@@ -0,0 +1,13 @@
+#include "../../simde/x86/sse.h"
+
+#include "test-mmx.h"
+
+#if !defined(SIMDE_TEST_X86_SSE)
+#define SIMDE_TEST_X86_SSE
+
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m128, f32)
+
+#define simde_assert_m128_close(a, b, precision) \
+  simde_assert_m128_f32_close_ex(__LINE__, __FILE__, a, b, precision)
+
+#endif /* !defined(SIMDE_TEST_X86_SSE) */

data/ext/minimap2/lib/simde/test/x86/test-sse2.h

@@ -0,0 +1,13 @@
+#include "../../simde/x86/sse2.h"
+
+#include "test-sse.h"
+
+#if !defined(SIMDE_TEST_X86_SSE2)
+#define SIMDE_TEST_X86_SSE2
+
+SIMDE_TEST_DEFINE_ASSERT_VEC_CLOSE(m128d, f64)
+
+#define simde_assert_m128d_close(a, b, precision) \
+  simde_assert_m128d_f64_close_ex(__LINE__, __FILE__, a, b, precision)
+
+#endif /* !defined(SIMDE_TEST_X86_SSE2) */

data/ext/minimap2/lib/simde/test/x86/test-x86-internal.h

@@ -0,0 +1,196 @@
+#if !defined(SIMDE_TESTS_X86_INTERNAL_H)
+#define SIMDE_TESTS_CURRENT_ARCH x86
+
+#include "../run-tests.h"
+
+/* Assert that two vectors are bit-identical without worring about the
+   underlying type. */
+#define simde_assert_vec_equal(a, b, T) do { \
+    const T##_private simde_a_ = T##_to_private(a); \
+    const T##_private simde_b_ = T##_to_private(b); \
+    for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.u32f) / sizeof(simde_a_.u32f[0]))) ; simde_i_++) { \
+      if (HEDLEY_UNLIKELY(simde_a_.u32f[simde_i_] != simde_b_.u32f[simde_i_])) { \
+        munit_errorf("assertion failed: " #a ".u32f[%d] (%" PRIxFAST32 ") != " #b ".u32f[%d] (%" PRIxFAST32 ")", \
+            simde_i_, simde_a_.u32f[simde_i_], \
+            simde_i_, simde_b_.u32f[simde_i_]); \
+      } \
+    } \
+  } while(0)
+#define simde_assert_m64_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m64)
+#define simde_assert_m128_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m128)
+#define simde_assert_m128i_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m128i)
+#define simde_assert_m128d_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m128d)
+#define simde_assert_m256_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m256)
+#define simde_assert_m256i_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m256i)
+#define simde_assert_m256d_equal(a, b) \
+  simde_assert_vec_equal(a, b, simde__m256d)
+
+/* Assert that every integer in two vectors are equal */
+#define simde_assert_vec_i(a, op, b, T, accessor, fmt) do { \
+      const T##_private simde_a_ = T##_to_private(a); \
+      const T##_private simde_b_ = T##_to_private(b); \
+      for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.accessor) / sizeof(simde_a_.accessor[0]))) ; simde_i_++) { \
+        if (HEDLEY_UNLIKELY(!(simde_a_.accessor[simde_i_] op simde_b_.accessor[simde_i_]))) { \
+          munit_errorf("assertion failed: " #a "." #accessor "[%d] " #op " " #b "." #accessor "[%d] (%" fmt " " #op " %" fmt ")", \
+              simde_i_, simde_i_, simde_a_.accessor[simde_i_], simde_b_.accessor[simde_i_]); \
+        } \
+      } \
+    } while (0)
+#define simde_assert_m512i_i8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i,  i8,  PRId8)
+#define simde_assert_m512i_i16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, i16, PRId16)
+#define simde_assert_m512i_i32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, i32, PRId32)
+#define simde_assert_m512i_i64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, i64, PRId64)
+#define simde_assert_m512i_u8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i,  u8,  PRIu8)
+#define simde_assert_m512i_u16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, u16, PRIu16)
+#define simde_assert_m512i_u32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, u32, PRIu32)
+#define simde_assert_m512i_u64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m512i, u64, PRIu64)
+#define simde_assert_m256i_i8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i,  i8,  PRId8)
+#define simde_assert_m256i_i16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, i16, PRId16)
+#define simde_assert_m256i_i32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, i32, PRId32)
+#define simde_assert_m256i_i64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, i64, PRId64)
+#define simde_assert_m256i_u8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i,  u8,  PRIu8)
+#define simde_assert_m256i_u16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, u16, PRIu16)
+#define simde_assert_m256i_u32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, u32, PRIu32)
+#define simde_assert_m256i_u64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m256i, u64, PRIu64)
+#define simde_assert_m128i_i8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i,  i8,  PRId8)
+#define simde_assert_m128i_i16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, i16, PRId16)
+#define simde_assert_m128i_i32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, i32, PRId32)
+#define simde_assert_m128i_i64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, i64, PRId64)
+#define simde_assert_m128i_u8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i,  u8,  PRIu8)
+#define simde_assert_m128i_u16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, u16, PRIu16)
+#define simde_assert_m128i_u32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, u32, PRIu32)
+#define simde_assert_m128i_u64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m128i, u64, PRIu64)
+#define simde_assert_m64_i8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64,  i8,  PRId8)
+#define simde_assert_m64_i16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, i16, PRId16)
+#define simde_assert_m64_i32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, i32, PRId32)
+#define simde_assert_m64_i64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, i64, PRId64)
+#define simde_assert_m64_u8(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64,  u8,  PRIu8)
+#define simde_assert_m64_u16(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, u16, PRIu16)
+#define simde_assert_m64_u32(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, u32, PRIu32)
+#define simde_assert_m64_u64(a, op, b) \
+  simde_assert_vec_i(a, op, b, simde__m64, u64, PRIu64)
+
+/* Assert that the integer values in each vector are approximately equal. */
+#define simde_assert_vec_i_close(a, b, precision, T, accessor, fmt) do { \
+      const T##_private simde_a_ = T##_to_private(a); \
+      const T##_private simde_b_ = T##_to_private(b); \
+      for (int simde_i_ = 0 ; simde_i_ < HEDLEY_STATIC_CAST(int, (sizeof(simde_a_.accessor) / sizeof(simde_a_.accessor[0]))) ; simde_i_++) { \
+        if (!((simde_a_.accessor[simde_i_] <= (simde_b_.accessor[simde_i_] + precision)) && (simde_a_.accessor[simde_i_] >= (simde_b_.accessor[simde_i_] - precision)))) { \
+          munit_errorf("assertion failed: " #a "." #accessor "[%d] " SIMDE_ALMOST_EQUAL_TO " " #b "." #accessor "[%d] (%" fmt " " SIMDE_ALMOST_EQUAL_TO " %" fmt ")", \
+              simde_i_, simde_i_, simde_a_.accessor[simde_i_], simde_b_.accessor[simde_i_]); \
+        } \
+      } \
+    } while(0)
+
+#define simde_assert_m64_i8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, i8, PRId8)
+#define simde_assert_m64_i16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, i16, PRId16)
+#define simde_assert_m64_i32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, i32, PRId32)
+#define simde_assert_m64_i64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, i64, PRId64)
+#define simde_assert_m64_u8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, u8, PRIu8)
+#define simde_assert_m64_u16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, u16, PRIu16)
+#define simde_assert_m64_u32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, u32, PRIu32)
+#define simde_assert_m64_u64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m64, u64, PRIu64)
+#define simde_assert_m128i_i8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, i8, PRId8)
+#define simde_assert_m128i_i16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, i16, PRId16)
+#define simde_assert_m128i_i32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, i32, PRId32)
+#define simde_assert_m128i_i64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, i64, PRId64)
+#define simde_assert_m128i_u8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, u8, PRIu8)
+#define simde_assert_m128i_u16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, u16, PRIu16)
+#define simde_assert_m128i_u32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, u32, PRIu32)
+#define simde_assert_m128i_u64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m128i, u64, PRIu64)
+#define simde_assert_m256i_i8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, i8, PRId8)
+#define simde_assert_m256i_i16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, i16, PRId16)
+#define simde_assert_m256i_i32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, i32, PRId32)
+#define simde_assert_m256i_i64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, i64, PRId64)
+#define simde_assert_m256i_u8_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, u8, PRIu8)
+#define simde_assert_m256i_u16_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, u16, PRIu16)
+#define simde_assert_m256i_u32_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, u32, PRIu32)
+#define simde_assert_m256i_u64_close(a, b, precision) \
+  simde_assert_vec_i_close(a, b, precision, simde__m256i, u64, PRIu64)
+
+HEDLEY_BEGIN_C_DECLS
+
+#define SIMDE_TESTS_GENERATE_SUITE_GETTERS(isax) \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, cpp)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)(void); \
+  MunitSuite* SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   cpp)(void)
+
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(mmx);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse2);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse3);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(ssse3);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse4_1);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(sse4_2);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(fma);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx2);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512f);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512bw);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(avx512vl);
+SIMDE_TESTS_GENERATE_SUITE_GETTERS(svml);
+
+HEDLEY_END_C_DECLS
+
+#endif /* !defined(SIMDE_TESTS_X86_INTERNAL_H) */

data/ext/minimap2/lib/simde/test/x86/test-x86.c

@@ -0,0 +1,48 @@
+#include "test-x86.h"
+#include "test-x86-internal.h"
+
+#include <stdio.h>
+
+#if defined(SIMDE_BUILD_CPP_TESTS)
+#define SUITES_PER_ISAX 4
+#define SET_CHILDREN_FOR_ARCH(isax) \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(); \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)(); \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, cpp)(); \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   cpp)()
+#else
+#define SUITES_PER_ISAX 2
+#define SET_CHILDREN_FOR_ARCH(isax) \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, native, c)(); \
+  children[i++] = *SIMDE_TESTS_GENERATE_SYMBOL_FULL(suite, SIMDE_TESTS_CURRENT_ARCH, isax, emul,   c)()
+#endif
+
+MunitSuite*
+simde_tests_x86_get_suite(void) {
+  static MunitSuite children[(14 * SUITES_PER_ISAX) + 1];
+  static MunitSuite suite = { "/x86", NULL, children, 1, MUNIT_SUITE_OPTION_NONE };
+  static const MunitSuite empty = { NULL, NULL, NULL, 1, MUNIT_SUITE_OPTION_NONE };
+
+  size_t i = 0;
+
+  SET_CHILDREN_FOR_ARCH(mmx);
+  SET_CHILDREN_FOR_ARCH(sse);
+  SET_CHILDREN_FOR_ARCH(sse2);
+  SET_CHILDREN_FOR_ARCH(sse3);
+  SET_CHILDREN_FOR_ARCH(ssse3);
+  SET_CHILDREN_FOR_ARCH(sse4_1);
+  SET_CHILDREN_FOR_ARCH(sse4_2);
+  SET_CHILDREN_FOR_ARCH(avx);
+  SET_CHILDREN_FOR_ARCH(fma);
+  SET_CHILDREN_FOR_ARCH(avx2);
+  SET_CHILDREN_FOR_ARCH(avx512f);
+  SET_CHILDREN_FOR_ARCH(avx512bw);
+  SET_CHILDREN_FOR_ARCH(avx512vl);
+  SET_CHILDREN_FOR_ARCH(svml);
+
+  children[i++] = empty;
+
+  munit_assert_size(i, <=, sizeof(children) / sizeof(children[0]));
+
+  return &suite;
+}

data/ext/minimap2/lib/simde/test/x86/test-x86.h

@@ -0,0 +1,8 @@
+#include "../../simde/hedley.h"
+#include "../munit/munit.h"
+
+HEDLEY_BEGIN_C_DECLS
+
+MunitSuite* simde_tests_x86_get_suite(void);
+
+HEDLEY_END_C_DECLS

data/ext/minimap2/main.c

@@ -7,8 +7,6 @@
 #include "mmpriv.h"
 #include "ketopt.h"
 
-#define MM_VERSION "2.24-r1122"
-
 #ifdef __linux__
 #include <sys/resource.h>
 #include <sys/time.h>
@@ -78,6 +76,7 @@ static ko_longopt_t long_options[] = {
 	{ "chain-skip-scale",ko_required_argument,351 },
 	{ "print-chains",   ko_no_argument,       352 },
 	{ "no-hash-name",   ko_no_argument,       353 },
+	{ "secondary-seq",  ko_no_argument,       354 },
 	{ "help",           ko_no_argument,       'h' },
 	{ "max-intron-len", ko_required_argument, 'G' },
 	{ "version",        ko_no_argument,       'V' },
@@ -121,7 +120,7 @@ static inline void yes_or_no(mm_mapopt_t *opt, int64_t flag, int long_idx, const
 
 int main(int argc, char *argv[])
 {
-	const char *opt_str = "2aSDw:k:K:t:r:f:Vv:g:G:I:d:XT:s:x:Hcp:M:n:z:A:B:O:E:m:N:Qu:R:hF:LC:yYPo:e:U:";
+	const char *opt_str = "2aSDw:k:K:t:r:f:Vv:g:G:I:d:XT:s:x:Hcp:M:n:z:A:B:O:E:m:N:Qu:R:hF:LC:yYPo:e:U:J:";
 	ketopt_t o = KETOPT_INIT;
 	mm_mapopt_t opt;
 	mm_idxopt_t ipt;
@@ -187,7 +186,12 @@ int main(int argc, char *argv[])
 		else if (c == 'R') rg = o.arg;
 		else if (c == 'h') fp_help = stdout;
 		else if (c == '2') opt.flag |= MM_F_2_IO_THREADS;
-		else if (c == 'o') {
+		else if (c == 'J') {
+			int t;
+			t = atoi(o.arg);
+			if (t == 0) opt.flag |= MM_F_SPLICE_OLD;
+			else if (t == 1) opt.flag &= ~MM_F_SPLICE_OLD;
+		} else if (c == 'o') {
 			if (strcmp(o.arg, "-") != 0) {
 				if (freopen(o.arg, "wb", stdout) == NULL) {
 					fprintf(stderr, "[ERROR]\033[1;31m failed to write the output to file '%s'\033[0m: %s\n", o.arg, strerror(errno));
@@ -237,6 +241,7 @@ int main(int argc, char *argv[])
 		else if (c == 350) opt.q_occ_frac = atof(o.arg); // --q-occ-frac
 		else if (c == 352) mm_dbg_flag |= MM_DBG_PRINT_CHAIN; // --print-chains
 		else if (c == 353) opt.flag |= MM_F_NO_HASH_NAME; // --no-hash-name
+		else if (c == 354) opt.flag |= MM_F_SECONDARY_SEQ; // --secondary-seq
 		else if (c == 330) {
 			fprintf(stderr, "[WARNING] \033[1;31m --lj-min-ratio has been deprecated.\033[0m\n");
 		} else if (c == 314) { // --frag
@@ -261,7 +266,8 @@ int main(int argc, char *argv[])
 		} else if (c == 326) { // --dual
 			yes_or_no(&opt, MM_F_NO_DUAL, o.longidx, o.arg, 0);
 		} else if (c == 347) { // --rmq
-			yes_or_no(&opt, MM_F_RMQ, o.longidx, o.arg, 1);
+			if (o.arg) yes_or_no(&opt, MM_F_RMQ, o.longidx, o.arg, 1);
+			else opt.flag |= MM_F_RMQ;
 		} else if (c == 'S') {
 			opt.flag |= MM_F_OUT_CS | MM_F_CIGAR | MM_F_OUT_CS_LONG;
 			if (mm_verbose >= 2)
@@ -322,7 +328,7 @@ int main(int argc, char *argv[])
 		fprintf(fp_help, "    -H           use homopolymer-compressed k-mer (preferrable for PacBio)\n");
 		fprintf(fp_help, "    -k INT       k-mer size (no larger than 28) [%d]\n", ipt.k);
 		fprintf(fp_help, "    -w INT       minimizer window size [%d]\n", ipt.w);
-		fprintf(fp_help, "    -I NUM       split index for every ~NUM input bases [4G]\n");
+		fprintf(fp_help, "    -I NUM       split index for every ~NUM input bases [8G]\n");
 		fprintf(fp_help, "    -d FILE      dump index to FILE []\n");
 		fprintf(fp_help, "  Mapping:\n");
 		fprintf(fp_help, "    -f FLOAT     filter out top FLOAT fraction of repetitive minimizers [%g]\n", opt.mid_occ_frac);
@@ -344,6 +350,7 @@ int main(int argc, char *argv[])
 		fprintf(fp_help, "    -z INT[,INT] Z-drop score and inversion Z-drop score [%d,%d]\n", opt.zdrop, opt.zdrop_inv);
 		fprintf(fp_help, "    -s INT       minimal peak DP alignment score [%d]\n", opt.min_dp_max);
 		fprintf(fp_help, "    -u CHAR      how to find GT-AG. f:transcript strand, b:both strands, n:don't match GT-AG [n]\n");
+		fprintf(fp_help, "    -J INT       splice mode. 0: original minimap2 model; 1: miniprot model [1]\n");
 		fprintf(fp_help, "  Input/Output:\n");
 		fprintf(fp_help, "    -a           output in the SAM format (PAF by default)\n");
 		fprintf(fp_help, "    -o FILE      output alignments to FILE [stdout]\n");

data/ext/minimap2/map.c

@@ -10,11 +10,6 @@
 #include "bseq.h"
 #include "khash.h"
 
-struct mm_tbuf_s {
-	void *km;
-	int rep_len, frag_gap;
-};
-
 mm_tbuf_t *mm_tbuf_init(void)
 {
 	mm_tbuf_t *b;

data/ext/minimap2/minimap.h

@@ -5,41 +5,45 @@
 #include <stdio.h>
 #include <sys/types.h>
 
-#define MM_F_NO_DIAG       0x001 // no exact diagonal hit
-#define MM_F_NO_DUAL       0x002 // skip pairs where query name is lexicographically larger than target name
-#define MM_F_CIGAR         0x004
-#define MM_F_OUT_SAM       0x008
-#define MM_F_NO_QUAL       0x010
-#define MM_F_OUT_CG        0x020
-#define MM_F_OUT_CS        0x040
-#define MM_F_SPLICE        0x080 // splice mode
-#define MM_F_SPLICE_FOR    0x100 // match GT-AG
-#define MM_F_SPLICE_REV    0x200 // match CT-AC, the reverse complement of GT-AG
-#define MM_F_NO_LJOIN      0x400
-#define MM_F_OUT_CS_LONG   0x800
-#define MM_F_SR            0x1000
-#define MM_F_FRAG_MODE     0x2000
-#define MM_F_NO_PRINT_2ND  0x4000
-#define MM_F_2_IO_THREADS  0x8000
-#define MM_F_LONG_CIGAR    0x10000
-#define MM_F_INDEPEND_SEG  0x20000
-#define MM_F_SPLICE_FLANK  0x40000
-#define MM_F_SOFTCLIP      0x80000
-#define MM_F_FOR_ONLY      0x100000
-#define MM_F_REV_ONLY      0x200000
-#define MM_F_HEAP_SORT     0x400000
-#define MM_F_ALL_CHAINS    0x800000
-#define MM_F_OUT_MD        0x1000000
-#define MM_F_COPY_COMMENT  0x2000000
-#define MM_F_EQX           0x4000000 // use =/X instead of M
-#define MM_F_PAF_NO_HIT    0x8000000 // output unmapped reads to PAF
-#define MM_F_NO_END_FLT    0x10000000
-#define MM_F_HARD_MLEVEL   0x20000000
-#define MM_F_SAM_HIT_ONLY  0x40000000
+#define MM_VERSION "2.25-r1173"
+
+#define MM_F_NO_DIAG       (0x001LL) // no exact diagonal hit
+#define MM_F_NO_DUAL       (0x002LL) // skip pairs where query name is lexicographically larger than target name
+#define MM_F_CIGAR         (0x004LL)
+#define MM_F_OUT_SAM       (0x008LL)
+#define MM_F_NO_QUAL       (0x010LL)
+#define MM_F_OUT_CG        (0x020LL)
+#define MM_F_OUT_CS        (0x040LL)
+#define MM_F_SPLICE        (0x080LL) // splice mode
+#define MM_F_SPLICE_FOR    (0x100LL) // match GT-AG
+#define MM_F_SPLICE_REV    (0x200LL) // match CT-AC, the reverse complement of GT-AG
+#define MM_F_NO_LJOIN      (0x400LL)
+#define MM_F_OUT_CS_LONG   (0x800LL)
+#define MM_F_SR            (0x1000LL)
+#define MM_F_FRAG_MODE     (0x2000LL)
+#define MM_F_NO_PRINT_2ND  (0x4000LL)
+#define MM_F_2_IO_THREADS  (0x8000LL)
+#define MM_F_LONG_CIGAR    (0x10000LL)
+#define MM_F_INDEPEND_SEG  (0x20000LL)
+#define MM_F_SPLICE_FLANK  (0x40000LL)
+#define MM_F_SOFTCLIP      (0x80000LL)
+#define MM_F_FOR_ONLY      (0x100000LL)
+#define MM_F_REV_ONLY      (0x200000LL)
+#define MM_F_HEAP_SORT     (0x400000LL)
+#define MM_F_ALL_CHAINS    (0x800000LL)
+#define MM_F_OUT_MD        (0x1000000LL)
+#define MM_F_COPY_COMMENT  (0x2000000LL)
+#define MM_F_EQX           (0x4000000LL) // use =/X instead of M
+#define MM_F_PAF_NO_HIT    (0x8000000LL) // output unmapped reads to PAF
+#define MM_F_NO_END_FLT    (0x10000000LL)
+#define MM_F_HARD_MLEVEL   (0x20000000LL)
+#define MM_F_SAM_HIT_ONLY  (0x40000000LL)
 #define MM_F_RMQ           (0x80000000LL)
 #define MM_F_QSTRAND       (0x100000000LL)
 #define MM_F_NO_INV        (0x200000000LL)
 #define MM_F_NO_HASH_NAME  (0x400000000LL)
+#define MM_F_SPLICE_OLD    (0x800000000LL)
+#define MM_F_SECONDARY_SEQ (0x1000000000LL)	//output SEQ field for seqondary alignments using hard clipping
 
 #define MM_I_HPC          0x1
 #define MM_I_NO_SEQ       0x2
@@ -189,6 +193,11 @@ typedef struct {
 } mm_idx_reader_t;
 
 // memory buffer for thread-local storage during mapping
+struct mm_tbuf_s {
+	void *km;
+	int rep_len, frag_gap;
+};
+
 typedef struct mm_tbuf_s mm_tbuf_t;
 
 // global variables

data/ext/minimap2/minimap2.1

@@ -1,4 +1,4 @@
-.TH minimap2 1 "18 December 2021" "minimap2-2.24 (r1122)" "Bioinformatics tools"
+.TH minimap2 1 "25 April 2023" "minimap2-2.25 (r1173)" "Bioinformatics tools"
 .SH NAME
 .PP
 minimap2 - mapping and alignment between collections of DNA sequences
@@ -79,6 +79,19 @@ Minimizer k-mer length [15]
 .BI -w \ INT
 Minimizer window size [10]. A minimizer is the smallest k-mer
 in a window of w consecutive k-mers.
+.TP
+.BI -j \ INT
+Syncmer submer size [10]. Option
+.B -j
+and
+.B -w
+will override each: if
+.B -w
+is applied after
+.BR -j ,
+.B -j
+will have no effect, and vice versa.
+
 .TP
 .B -H
 Use homopolymer-compressed (HPC) minimizers. An HPC sequence is constructed by
@@ -88,16 +101,17 @@ on the HPC sequence.
 .BI -I \ NUM
 Load at most
 .I NUM
-target bases into RAM for indexing [4G]. If there are more than
+target bases into RAM for indexing [8G]. If there are more than
 .I NUM
 bases in
 .IR target.fa ,
 minimap2 needs to read
 .I query.fa
-multiple times to map it against each batch of target sequences.
+multiple times to map it against each batch of target sequences. This would create a multi-part index.
 .I NUM
 may be ending with k/K/m/M/g/G. NB: mapping quality is incorrect given a
-multi-part index.
+multi-part index. See also option
+.BR --split-prefix .
 .TP
 .B --idx-no-seq
 Don't store target sequences in the index. It saves disk space and memory but
@@ -587,7 +601,7 @@ Up to 20% sequence divergence.
 .B splice
 Long-read spliced alignment
 .RB ( -k15
-.B -w5 --splice -g2k -G200k -A1 -B2 -O2,32 -E1,0 -b0 -C9 -z200 -ub --junc-bonus=9 --cap-sw-mem=0
+.B -w5 --splice -g2k -G200k -A1 -B2 -O2,32 -E1,0 -C9 -z200 -ub --junc-bonus=9 --cap-sw-mem=0
 .BR --splice-flank=yes ).
 In the splice mode, 1) long deletions are taken as introns and represented as
 the