xengsort 2.2.1__tar.gz → 2.2.2__tar.gz

{xengsort-2.2.1/xengsort.egg-info → xengsort-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xengsort
-Version: 2.2.1
+Version: 2.2.2
 Summary: xenograft sorting of FASTQ reads into five categories: host, graft, both, neither, ambiguous.
 Author-email: Jens Zentgraf <zentgraf@cs.uni-saarland.de>, Sven Rahmann <rahmann@cs.uni-saarland.de>
 License: MIT License
@@ -52,6 +52,7 @@ This tool, xengsort, uses 3-way bucketed Cuckoo hashing to efficiently solve the
 For a description of the method an evaluation on several datasets, please see our
 [article in "Algorithms for Molecular Biology"](https://almob.biomedcentral.com/articles/10.1186/s13015-021-00181-w), or the initial [WABI 2020 publication](https://drops.dagstuhl.de/opus/volltexte/2020/12793/).
 (There was also a [preprint on bioRxiv](https://www.biorxiv.org/content/10.1101/2020.05.14.095604v2).)
+If you use xengsort to sort converted reads (RRBS or WGBS) there is a [bioRxiv preprint](https://www.biorxiv.org/content/10.64898/2026.10.06.756952v1.abstract) available.
 BibTeX entrys for citation can be found at the end of this README file.
 
 In case of problems,
@@ -71,24 +72,23 @@ Thank you!
 
 We here provide an example showing how to run xengsort on a human-captured mouse exome (part of one of the datasets described in the paper).
 This tutorial uses the workflow management system `Snakemake` to run the example.
-This is, however, not necessary to use `xengsort`. 
+This is, however, not necessary to use `xengsort`.
 Please refer to the Usage Guide below to learn how to run `xengsort` on your own data manually.
 
 
 Our software `xengsort` is provided as a Python package.
-For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package. 
+For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package.
 We here use the package manager [conda](https://docs.conda.io/en/latest/) to manage Python packages and to use a separate environment for `xengsort`.
 
 
-### Install the conda package manager (miniconda)
-Go to https://docs.conda.io/en/latest/miniconda.html and download the Miniconda installer:
-Choose Python 3.10 (or higher), your operating system, and preferably the 64 bit version.
-Follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it). 
+### Install the conda package manager (conda-forge)
+Go to https://conda-forge.org/download/ and download the conda-forge installer:
+Choose your operating system, follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it).
 You can let the installer do it, or do it manually by editing your ``.bashrc`` or similar file under Linux or MacOS, or by editing the environment variables under Windows.
 To verify that the installation works, open a new terminal and execute
 ```
-conda --version # ideally 22.9.xx or higher
-python --version # ideally 3.10.xx or higher
+conda --version # ideally 26.9.xx or higher
+python --version # ideally 3.12.xx or higher
 ```
 
 
@@ -122,7 +122,7 @@ within the cloned directory tree.
 
 
 ### Create and activate a conda environment
-To run our software, a [conda](https://docs.conda.io/en/latest/) environment with the required libraries needs to be created.
+To run our software, a [conda](https://conda-forge.org/docs/) environment with the required libraries needs to be created.
 A list of needed libraries is provided in the ``environment.yml`` file in the cloned repository;
 it can be used to create a new environment:
 
@@ -133,7 +133,7 @@ conda env create
 which will create an environment named ``xengsort`` with the required dependencies,
 using the provided ``environment.yml`` file in the same directory.
 
-A more explicit alternative is to run 
+A more explicit alternative is to run
 ```
 conda create --name xengsort -c conda-forge -c bioconda --file requirements.txt
 ```
@@ -217,11 +217,11 @@ To build an index for xengsort, several parameters must be provided, which are d
 First, a file name and a path for the index must be chosen.
 The index is stored in two files. We will use `myindex` to store the index in the current folder.
 
-Second, two reference genomes (host and graft) must be provided (in FASTA files). 
-We assume that they are given as `host.fa.gz` and `graft.fa.gz`. 
+Second, two reference genomes (host and graft) must be provided (in FASTA files).
+We assume that they are given as `host.fa.gz` and `graft.fa.gz`.
 The files can be provided as an uncompressed file or compressed using `gzip`, `bzip2` or `xz`.
-The corresponding options are `-H` or `--host` and `-G` or `--graft`. 
-Each option can take several arguments as files. 
+The corresponding options are `-H` or `--host` and `-G` or `--graft`.
+Each option can take several arguments as files.
 ```
 xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 4_500_000_000  [OPTIONS]
 ```
@@ -249,7 +249,7 @@ The final important parameter is about parallelization:
 
 Most of the parameters can also be provided in a config file (`.yaml`):
 - `--cfg` or `--config` defines the path the the config file.
- 
+
 ### How to classify
 
 To classify a FASTQ sample (one or several single-end or paired-end files), make sure you are in an environment where xengsort and its dependencies are installed.
@@ -257,7 +257,7 @@ Then run the `xengsort classify` command with a previously built index, such as
 ```
 xengsort classify --index myindex --fastq single.fq.gz --prefix myresults --mode count
 ```
-for single-end reads, or 
+for single-end reads, or
 ```
 xengsort classify --index myindex --fastq paired.1.fq.gz --pairs paired.2.fq.gz --prefix myresults --mode count
 ```
@@ -275,7 +275,7 @@ The parameter `--prefix` or equivalently `--out` is required and defines the pre
   - `{prefix}.both.1.fq.gz`: reads that could originate from both
   - `{prefix}.neither.1.fq.gz`: reads that originate from neither host nor graft
   - `{prefix}.ambiguous.1.fq.gz`: (few) ambiguous reads that cannot be classified,
-  
+
   and similarly with `.2.fq.gz`. For single-end reads, there is only `.fq.gz` (no numbers).
 
 The compression type can be specified using the `--compression` parameter.
@@ -301,7 +301,7 @@ xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 9_000_000_000 --b
 If an index is build using the bisulfite parameter, also the read is converted in the classification step.
 It is not necessary to change the parameters of the classification step.
 Currently, it only supports the count-based classification.
-
+A detailed description on how the benchmarks on bisulfite sequencing data was performed can be found [here](https://github.com/S-Altend/MethSortBench/tree/main/03_read_sorting).
 
 Please report a [GitLab issue](https://gitlab.com/genomeinformatics/xengsort/-/issues) in case of problems.
 
@@ -315,13 +315,13 @@ Happy sorting!
 *  **Snakemake throws errors when attempting to download the example dataset from SRA**.
 
 This may happen for several reasons:
-  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files. 
+  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files.
   1. Another source of trouble may be that for some reason and older version of `sra-tools` gets called. We use the `fasterq-dump` tool to download the data, which did not exist in older verisons. To use a clean environment with a recent version of `sra-tools`, you can run snakemake as `snakemake -j 16 --use-conda`, which will generate a separate environment only for the download (this takes additional time, but may resolve the problem).
   1. In earlier versions, the dataset was downloaded from a different location which is no longer available. Please check that you are using at least v1.1.0 (`xengsort --version`). If not, please do a fresh clone and follow the tutorial to set up a new environment (delete the old one first) and run `pip install -e .`, as explained above in the tutorial.
 
 *  **Indexing stops after a few seconds with a failure.**
 
-The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter). 
+The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter).
 (From version 1.0.1, the `-n` parameter is required, and the error cannot occur anymore. Please update to the latest version!)
 For the human and mouse genomes this is approximately `-n 4_500_000_000` (4.5 billion).
 It is unfortunately a limitation of the implementation that the hash table size has to be specified in advance.
@@ -377,3 +377,14 @@ In addition, you may also cite the WABI 2020 proceedigs paper:
   annote =	{Keywords: xenograft sorting, alignment-free method, Cuckoo hashing, k-mer}
 }
 ```
+
+If you use xengsort to sort converted reads, please also cite our corresponding bioRxiv preprint:
+```
+@article {Altendorfer2026.10.06.756952,
+  author = {Altendorfer, Stefan and Zentgraf, Jens and Schmitz, Johanna Elena and Plass, Christoph and Gerh{\"a}user, Clarissa and Rahmann, Sven},
+  title = {High-performance xenograft read-sorting for DNA methylation analysis},
+  year = {2026},
+  doi = {10.64898/2026.10.06.756952},
+  journal = {bioRxiv}
+}
+```

{xengsort-2.2.1 → xengsort-2.2.2}/README.md

@@ -5,6 +5,7 @@ This tool, xengsort, uses 3-way bucketed Cuckoo hashing to efficiently solve the
 For a description of the method an evaluation on several datasets, please see our
 [article in "Algorithms for Molecular Biology"](https://almob.biomedcentral.com/articles/10.1186/s13015-021-00181-w), or the initial [WABI 2020 publication](https://drops.dagstuhl.de/opus/volltexte/2020/12793/).
 (There was also a [preprint on bioRxiv](https://www.biorxiv.org/content/10.1101/2020.05.14.095604v2).)
+If you use xengsort to sort converted reads (RRBS or WGBS) there is a [bioRxiv preprint](https://www.biorxiv.org/content/10.64898/2026.10.06.756952v1.abstract) available.
 BibTeX entrys for citation can be found at the end of this README file.
 
 In case of problems,
@@ -24,24 +25,23 @@ Thank you!
 
 We here provide an example showing how to run xengsort on a human-captured mouse exome (part of one of the datasets described in the paper).
 This tutorial uses the workflow management system `Snakemake` to run the example.
-This is, however, not necessary to use `xengsort`. 
+This is, however, not necessary to use `xengsort`.
 Please refer to the Usage Guide below to learn how to run `xengsort` on your own data manually.
 
 
 Our software `xengsort` is provided as a Python package.
-For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package. 
+For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package.
 We here use the package manager [conda](https://docs.conda.io/en/latest/) to manage Python packages and to use a separate environment for `xengsort`.
 
 
-### Install the conda package manager (miniconda)
-Go to https://docs.conda.io/en/latest/miniconda.html and download the Miniconda installer:
-Choose Python 3.10 (or higher), your operating system, and preferably the 64 bit version.
-Follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it). 
+### Install the conda package manager (conda-forge)
+Go to https://conda-forge.org/download/ and download the conda-forge installer:
+Choose your operating system, follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it).
 You can let the installer do it, or do it manually by editing your ``.bashrc`` or similar file under Linux or MacOS, or by editing the environment variables under Windows.
 To verify that the installation works, open a new terminal and execute
 ```
-conda --version # ideally 22.9.xx or higher
-python --version # ideally 3.10.xx or higher
+conda --version # ideally 26.9.xx or higher
+python --version # ideally 3.12.xx or higher
 ```
 
 
@@ -75,7 +75,7 @@ within the cloned directory tree.
 
 
 ### Create and activate a conda environment
-To run our software, a [conda](https://docs.conda.io/en/latest/) environment with the required libraries needs to be created.
+To run our software, a [conda](https://conda-forge.org/docs/) environment with the required libraries needs to be created.
 A list of needed libraries is provided in the ``environment.yml`` file in the cloned repository;
 it can be used to create a new environment:
 
@@ -86,7 +86,7 @@ conda env create
 which will create an environment named ``xengsort`` with the required dependencies,
 using the provided ``environment.yml`` file in the same directory.
 
-A more explicit alternative is to run 
+A more explicit alternative is to run
 ```
 conda create --name xengsort -c conda-forge -c bioconda --file requirements.txt
 ```
@@ -170,11 +170,11 @@ To build an index for xengsort, several parameters must be provided, which are d
 First, a file name and a path for the index must be chosen.
 The index is stored in two files. We will use `myindex` to store the index in the current folder.
 
-Second, two reference genomes (host and graft) must be provided (in FASTA files). 
-We assume that they are given as `host.fa.gz` and `graft.fa.gz`. 
+Second, two reference genomes (host and graft) must be provided (in FASTA files).
+We assume that they are given as `host.fa.gz` and `graft.fa.gz`.
 The files can be provided as an uncompressed file or compressed using `gzip`, `bzip2` or `xz`.
-The corresponding options are `-H` or `--host` and `-G` or `--graft`. 
-Each option can take several arguments as files. 
+The corresponding options are `-H` or `--host` and `-G` or `--graft`.
+Each option can take several arguments as files.
 ```
 xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 4_500_000_000  [OPTIONS]
 ```
@@ -202,7 +202,7 @@ The final important parameter is about parallelization:
 
 Most of the parameters can also be provided in a config file (`.yaml`):
 - `--cfg` or `--config` defines the path the the config file.
- 
+
 ### How to classify
 
 To classify a FASTQ sample (one or several single-end or paired-end files), make sure you are in an environment where xengsort and its dependencies are installed.
@@ -210,7 +210,7 @@ Then run the `xengsort classify` command with a previously built index, such as
 ```
 xengsort classify --index myindex --fastq single.fq.gz --prefix myresults --mode count
 ```
-for single-end reads, or 
+for single-end reads, or
 ```
 xengsort classify --index myindex --fastq paired.1.fq.gz --pairs paired.2.fq.gz --prefix myresults --mode count
 ```
@@ -228,7 +228,7 @@ The parameter `--prefix` or equivalently `--out` is required and defines the pre
   - `{prefix}.both.1.fq.gz`: reads that could originate from both
   - `{prefix}.neither.1.fq.gz`: reads that originate from neither host nor graft
   - `{prefix}.ambiguous.1.fq.gz`: (few) ambiguous reads that cannot be classified,
-  
+
   and similarly with `.2.fq.gz`. For single-end reads, there is only `.fq.gz` (no numbers).
 
 The compression type can be specified using the `--compression` parameter.
@@ -254,7 +254,7 @@ xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 9_000_000_000 --b
 If an index is build using the bisulfite parameter, also the read is converted in the classification step.
 It is not necessary to change the parameters of the classification step.
 Currently, it only supports the count-based classification.
-
+A detailed description on how the benchmarks on bisulfite sequencing data was performed can be found [here](https://github.com/S-Altend/MethSortBench/tree/main/03_read_sorting).
 
 Please report a [GitLab issue](https://gitlab.com/genomeinformatics/xengsort/-/issues) in case of problems.
 
@@ -268,13 +268,13 @@ Happy sorting!
 *  **Snakemake throws errors when attempting to download the example dataset from SRA**.
 
 This may happen for several reasons:
-  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files. 
+  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files.
   1. Another source of trouble may be that for some reason and older version of `sra-tools` gets called. We use the `fasterq-dump` tool to download the data, which did not exist in older verisons. To use a clean environment with a recent version of `sra-tools`, you can run snakemake as `snakemake -j 16 --use-conda`, which will generate a separate environment only for the download (this takes additional time, but may resolve the problem).
   1. In earlier versions, the dataset was downloaded from a different location which is no longer available. Please check that you are using at least v1.1.0 (`xengsort --version`). If not, please do a fresh clone and follow the tutorial to set up a new environment (delete the old one first) and run `pip install -e .`, as explained above in the tutorial.
 
 *  **Indexing stops after a few seconds with a failure.**
 
-The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter). 
+The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter).
 (From version 1.0.1, the `-n` parameter is required, and the error cannot occur anymore. Please update to the latest version!)
 For the human and mouse genomes this is approximately `-n 4_500_000_000` (4.5 billion).
 It is unfortunately a limitation of the implementation that the hash table size has to be specified in advance.
@@ -330,3 +330,14 @@ In addition, you may also cite the WABI 2020 proceedigs paper:
   annote =	{Keywords: xenograft sorting, alignment-free method, Cuckoo hashing, k-mer}
 }
 ```
+
+If you use xengsort to sort converted reads, please also cite our corresponding bioRxiv preprint:
+```
+@article {Altendorfer2026.10.06.756952,
+  author = {Altendorfer, Stefan and Zentgraf, Jens and Schmitz, Johanna Elena and Plass, Christoph and Gerh{\"a}user, Clarissa and Rahmann, Sven},
+  title = {High-performance xenograft read-sorting for DNA methylation analysis},
+  year = {2026},
+  doi = {10.64898/2026.10.06.756952},
+  journal = {bioRxiv}
+}
+```

{xengsort-2.2.1 → xengsort-2.2.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xengsort"
-version = "2.2.1"
+version = "2.2.2"
 
 license = {file = "LICENSE"}
 

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/cptasks_kmers.py

@@ -544,15 +544,27 @@ def compile_cptask_insert_filtered_subkeys(
         myfilter,
         constant_value=0,
         maxfailures=0,
-        maxwalk=1000):
+        maxwalk=1000,
+        prefetch_distance=8):
     debugprint0, debugprint1, debugprint2 = debug.debugprint
     dassert = debug.dassert
+
+    @njit(nogil=True)
+    def dummy_prefetch(*_):
+        return
+
+    prefetch_filter = prefetch_table = dummy_prefetch
     if myfilter is not None:
         wwo = "with"
         lookup_and_insert_in_subfilter = myfilter.private.lookup_and_insert_in_subfilter
+        table_prefetch_distance = 0
+        filter_prefetch_distance = prefetch_distance
+        prefetch_filter = myfilter.private.prefetch_block_by_subkey_subfilter
     else:
         wwo = "without"
-
+        table_prefetch_distance = prefetch_distance
+        filter_prefetch_distance = 0
+        prefetch_table = myhashtable.private.prefetch_subkey
         @njit(nogil=True)
         def lookup_and_insert_in_subfilter(ft, st, subkey):
             return True
@@ -599,7 +611,12 @@ def compile_cptask_insert_filtered_subkeys(
             # dassert(buffer_type == 1, __name__, 'buffer_type == 1', buffer_type, message='0 means sequence buffer')
 
             # consume the buffer
-            for subkey in active_buffer[:nsubkeys]:
+            for ii in range(nsubkeys):
+                subkey = active_buffer[ii]
+                if filter_prefetch_distance and ii + filter_prefetch_distance < nsubkeys:
+                    prefetch_filter(ft, active_buffer[ii + prefetch_distance], st)
+                if table_prefetch_distance and ii + table_prefetch_distance < nsubkeys:
+                    prefetch_table(ht, active_buffer[ii + prefetch_distance], st)
                 if lookup_and_insert_in_subfilter(ft, st, subkey):
                     status, result = update(ht, st, subkey, value)  # see docstring below
                     if status & 128 == 0:
@@ -618,9 +635,11 @@ def compile_cptask_insert_filtered_subkeys(
 
 def compile_cptask_update_existing_subkeys(
         myhashtable,
-        constant_value=1):
+        constant_value=1,
+        prefetch_distance=8):
     debugprint0, debugprint1, debugprint2 = debug.debugprint
     update_existing = myhashtable.private.update_existing_ssk
+    prefetch = myhashtable.private.prefetch_subkey
     value = uint64(constant_value)
     debugprint1(f"- compiling cptask_update_existing_subkeys: {constant_value=}")
 
@@ -652,6 +671,8 @@ def compile_cptask_update_existing_subkeys(
 
             # consume the buffer
             for ii in range(nsubkeys):
+                if prefetch_distance and ii + prefetch_distance < nsubkeys:
+                    prefetch(ht, active_buffer[ii + prefetch_distance], st)
                 subkey = active_buffer[ii]
                 _, _ = update_existing(ht, st, subkey, value)  # see docstring below
                 # status, result = update_existing(ht, st, subkey, value)  # see docstring below

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/hash_s3c_fbcbvb.py

@@ -134,6 +134,22 @@ def build_hash(universe, n, subtables, bucketsize,
     def prefetch_bucket(table, subtable, bucket):
         startbit = subtable * subtablebits + bucket * bucketsizebits
         hprefetch(table, startbit)
+        hprefetch(table, startbit + uint64(bucketsizebits - 1))
+
+    @njit(nogil=True, locals=dict(
+        bucket=int64, startbit=uint64))
+    def prefetch_subkey(table, subkey, subtable):
+        bucket, _ = get_bs1(subkey)
+        startbit = subtable * subtablebits + bucket * bucketsizebits
+        hprefetch(table, startbit)
+
+        bucket, _ = get_bs2(subkey)
+        startbit = subtable * subtablebits + bucket * bucketsizebits
+        hprefetch(table, startbit)
+
+        bucket, _ = get_bs3(subkey)
+        startbit = subtable * subtablebits + bucket * bucketsizebits
+        hprefetch(table, startbit)
 
     @njit(nogil=True, locals=dict(
         bucket=int64, startbit=uint64))

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/io/fastaio.py

@@ -103,6 +103,7 @@ def cptask_read_fasta_into_buffers(fd, W, inbuffers, incontrol, ininfos, outbuff
     inside_seq = True
     header_seq = False
     nseq = 0
+    last_seq_length = 2 * W
     while True:
         old = nactive
         old_buffer = active_buffer
@@ -134,7 +135,11 @@ def cptask_read_fasta_into_buffers(fd, W, inbuffers, incontrol, ininfos, outbuff
             if ntodo < 0:
                 errorcode = ntodo
                 break
+            # If we have a long header but a seq smaller W, the offset can be bigger than W
+            if header_seq and last_seq_length < W:
+                break
             # Nothing read and the offset is not a full (gapped) k-mer
+            # I think this should trigger
             if offset < W:
                 break
             # Nothing read but we still have some data in the buffer
@@ -157,7 +162,6 @@ def cptask_read_fasta_into_buffers(fd, W, inbuffers, incontrol, ininfos, outbuff
                 offset = (W - 1)
         else:
             offset = end_buffer - linemarkbuffers[nactive, nseq - 1, 3]
-
         outcontrol[nactive, 7] = nseq
         outcontrol[nactive, 6] = 0  # buffer type sequence data
 
@@ -417,7 +421,7 @@ def fastaextract(args):
     seps = args.separators
     sfx = [args.suffix] if args.suffix else []
     seps = [_SEPARATORS.get(sep.upper(), sep) for sep in seps]
-    if items is None: 
+    if items is None:
         items = list()
         seps = list()
     if len(seps) == 1:
@@ -436,7 +440,7 @@ def fastaextract(args):
 def get_header_info(header, items, assigner, seps):
     fields = header.decode("ascii").split()
     assigners = [i for (i, field) in enumerate(fields) if assigner in field]
-    if 0 in assigners: 
+    if 0 in assigners:
         assigners.remove(0)
     D = dict()
     if items is None:

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/io/fastqio.py

@@ -4,7 +4,7 @@ import numpy as np
 from numba import njit, int32, int64, uint64
 
 from .seqio import FormatError, _universal_reads
-from ..lowlevel.libc import read_block
+from ..lowlevel.libc import read_block, _memchr
 from ..lowlevel.conpro import \
     find_buffer_for_writing, \
     mark_buffer_for_reading, mark_buffer_for_writing
@@ -604,6 +604,7 @@ def _find_fastq_seqmarks(buf, linemarks, sequence_id=-1):
     if n == 0:
         return (0, 0)
     M = linemarks.shape[0]
+    start_ptr = buf.ctypes.data
     i = 0
     m = -1  # number of current record we're in
     nxt = 0  # byte of beginning of last record
@@ -633,13 +634,15 @@ def _find_fastq_seqmarks(buf, linemarks, sequence_id=-1):
             linemarks[m, 2] = i
         elif line == 1:
             linemarks[m, 0] = i
+
         # find end of current line
-        while buf[i] != 10:
-            i += 1
-            if i >= n:
-                # we did not find the end of the line before the buffer was exhausted
-                # we cannot set linemarks[m][1]
-                return (m, nxt)
+        next_ptr = _memchr(start_ptr + i, 10, n - i)
+        if next_ptr == 0:
+            # we did not find the end of the line before the buffer was exhausted
+            # we cannot set linemarks[m][1]
+            return (m, nxt)
+        i = next_ptr - start_ptr
+
         if line == 1:
             linemarks[m, 1] = i
         line = (line + 1) % 4

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/io/generalio.py

@@ -19,9 +19,18 @@ from .fastaio import \
 from .binaryio import \
     compile_cptask_read_data_into_buffers
 
+igzip_installed = False
+if which("igzip") is not None:
+    igzip_installed = True
+
+_gz_decompress = "igzip -d -c" if igzip_installed else "bgzip -cd"
 
 _in_suffixes = {
-    ".gz": "bgzip -cd",
+    # ".gz": "bgzip -cd",
+    # ".gz": "rapidgzip -d -c",
+    # ".gz": "rapidgzip-rust",
+    # ".gz": "igzip -d -c",
+    ".gz": _gz_decompress,
     ".bz2": "bzip2 -cd",
     ".xz": "xz -cd",
     ".zst": "zstd -cd",
@@ -34,6 +43,8 @@ _out_suffixes = {
     }
 _threads = {
     "bgzip": "@",
+    "rapidgzip": "P",
+    "rapidgzip-rust": "P",
     "xz": "T",
     "zstd": "T",
     }

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/io/hashio.py

@@ -54,7 +54,7 @@ from ..lowlevel.intbitarray import intbitarray
 from ..lowlevel.libc import write_block, write_uint64, write_dna
 
 
-_ATTRS_TO_SAVE = "hashtype choices nvalues subtables aligned universe nslots=n nbuckets bucketsize nfingerprints mem_bytes shortcutbits hashfuncs".split()
+_ATTRS_TO_SAVE = "hashtype choices nvalues subtables aligned universe nslots=n nbuckets bucketsize windowsize nfingerprints mem_bytes shortcutbits hashfuncs".split()
 _ATTR_PAIRS = [((name if '=' not in name else name.split("=")[0]), (name if '=' not in name else name.split("=")[1])) for name in _ATTRS_TO_SAVE]
 # TODO: see comment in save_hash on how to get rid of these
 
@@ -219,6 +219,12 @@ def load_hash(filename, *, shared_memory=False, info_only=False, quiet=False):
             bucketsize, hashfuncs, nvalues, update_value,
             aligned=aligned, nfingerprints=nfingerprints,
             init=init, maxwalk=maxwalk, shm=shm)
+    elif hashtype == 'ccrh':
+        h = m.build_hash(universe, n, subtables,
+            bucketsize, hashfuncs, nvalues, update_value,
+            aligned=aligned, nfingerprints=nfingerprints,
+            init=init, maxwalk=maxwalk, shortcutbits=shortcutbits,
+            windowsize=hashinfo['windowsize'], shm=shm)
     else:
         h = m.build_hash(universe, n, subtables,
             bucketsize, hashfuncs, nvalues, update_value,

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/kmers.py

@@ -605,6 +605,7 @@ def compile_get_gapped_kmers_issh(mask, rcmode='max', new_encoding=True, sampled
     w = mask.w
     if k < 1 or k > 32:
         raise ValueError(f"only 1<=k<=32 is supported, but k={k}.")
+
     revcomp, ccode = compile_revcomp_and_canonical_code_new(k, rcmode) if new_encoding else compile_revcomp_and_canonical_code_old(k, rcmode)
     invalid = uint64(np.iinfo(np.uint64).max)
     popcnt = compile_popcount('uint64')
@@ -686,7 +687,7 @@ def compile_get_gapped_kmers_issh(mask, rcmode='max', new_encoding=True, sampled
         contained_ns = contained_ns >> 1
 
         # compute gapped k-mers iteratively based on previous gapped k-mers
-        for i in range(start + last, (end - start) - (width - 1)):
+        for i in range(end_naive, (end - start) - (width - 1)):
             contained_ns = contained_ns << 1
             code = 0
             for k, shift, mask in steps:
@@ -701,13 +702,13 @@ def compile_get_gapped_kmers_issh(mask, rcmode='max', new_encoding=True, sampled
     @njit(nogil=True)
     def canonical_codes_inplace(arr, nhashes):
         for i in range(nhashes):
-            arr[i] = ccode(arr[i])
+            arr[i] = ccode(arr[i]) if arr[i] != invalid else invalid
         return nhashes
 
     @njit(nogil=True)
     def canonical_codes_sampled(arr, nhashes):
         for idx, hash_idx in enumerate(range(0, nhashes, w // 2)):
-            arr[idx] = ccode(arr[hash_idx])
+            arr[idx] = ccode(arr[i]) if arr[i] != invalid else invalid
         return idx + 1
 
     canonical_codes = canonical_codes_sampled if sampled else canonical_codes_inplace
@@ -716,7 +717,7 @@ def compile_get_gapped_kmers_issh(mask, rcmode='max', new_encoding=True, sampled
     def get_gapped_kmers(seq, hashes):
         hashes[:] = 0
         issh_processor_fast(hashes, seq, 0, len(seq))
-        return canonical_codes(hashes, len(seq) - w + 1)
+        return canonical_codes(hashes, max(0, len(seq) - w + 1))
 
     @njit(nogil=True)
     def get_gapped_kmers_forward(seq, hashes):

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/lowlevel/libc.py

@@ -49,6 +49,10 @@ def _setup_libc():
         _libc.write.argtypes = (ctypes.c_int, ctypes.c_void_p, ctypes.c_size_t)
         _write = _libc.write
 
+        _libc.memchr.restype = ctypes.c_ssize_t
+        _libc.memchr.argtypes = (ctypes.c_size_t, ctypes.c_int, ctypes.c_size_t)
+        _memchr = _libc.memchr
+
         if 'linux' in platform:
             _libc.__errno_location.argtypes = tuple()
             _libc.__errno_location.restype = ctypes.POINTER(ctypes.c_int)
@@ -61,7 +65,7 @@ def _setup_libc():
             raise NotImplementedError(msg)
 
         _errno = njit(nogil=True)(lambda: _errno_location()[0])
-        return _libc, _read, _write, _errno
+        return _libc, _read, _write, _memchr, _errno
 
     else:
         """
@@ -70,7 +74,17 @@ def _setup_libc():
         raise NotImplementedError(msg)
 
 
-libc, _read, _write, errno = _setup_libc()
+libc, _read, _write, _memchr, errno = _setup_libc()
+
+
+@njit(nogil=True)
+def next_char_at(buf, c):
+    start_ptr = buf.ctypes.data
+    nbytes = buf.shape[0]
+    res = _memchr(start_ptr, c, nbytes)
+    if res == 0:
+        return -1
+    return res - start_ptr
 
 
 @njit(nogil=True, locals=dict())  # offset=int32, buflen=int32, space=int32, res=int32, fill=int32, err=int32))

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/srhash.py

@@ -34,6 +34,7 @@ SRHash = namedtuple("SRHash", [
     "subtables",
     "nbuckets",
     "bucketsize",
+    "windowsize",  # window size for windowed hash types (hash_ccrh); 0 if unused
     "nfingerprints",
     "nvalues",
     "mem_bytes",
@@ -93,6 +94,7 @@ SRHash_private = namedtuple("SRHash_private", [
     "get_subkey_choice_from_bucket_signature",
     "prefetch_bucket",
     "prefetch_key",
+    "prefetch_subkey",
 
     # Copies of the public functions but with subtable/subkey interface
     # (only defined for hashes with subtables; otherwise None)
@@ -111,6 +113,7 @@ def create_SRHash(d):
     # The given d is copied and reduced to the required fields.
     # The hashfuncs tuple is reduced to a single ASCII bytestring.
     d0 = dict(d)
+    d0.setdefault('windowsize', 0)  # only windowed hash types (hash_ccrh) set this
     d0['mem_bytes'] = d0['hashtable'].nbytes
     d0['slots_nonempty'] = compile_slots_nonempty(d)
     d0['slots_with_value'] = compile_slots_with_value(d)

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/xengsort/xengsort_classify.py

@@ -821,10 +821,12 @@ def compile_classify_read_from_fastq(
             pass
 
     @contextmanager
-    def cond_contextmgr(name, suffix, count, filt):
+    def cond_contextmgr(name, suffix, count, filt, enabled=True):
         if count and filt:
             raise ValueError("ERROR: cannot use both --count and --filter option at the same time.")
-        if count:
+        if not enabled:
+            yield dummy_contextmgr()
+        elif count:
             yield dummy_contextmgr()
         elif filt:
             if "graft" in suffix:
@@ -840,7 +842,6 @@ def compile_classify_read_from_fastq(
         counts = [0, 0, 0, 0, 0, 0]  # host, graft, amb., both, neither
         nprocessed = 0
 
-        site_count = count and not use_start_sites
         with cond_contextmgr(path, f"-host.1.fq{compression}", count, filt) as host1, \
              cond_contextmgr(path, f"-host.2.fq{compression}", count, filt) as host2, \
              cond_contextmgr(path, f"-graft.1.fq{compression}", count, filt) as graft1, \
@@ -851,8 +852,8 @@ def compile_classify_read_from_fastq(
              cond_contextmgr(path, f"-both.2.fq{compression}", count, filt) as both2, \
              cond_contextmgr(path, f"-neither.1.fq{compression}", count, filt) as neither1, \
              cond_contextmgr(path, f"-neither.2.fq{compression}", count, filt) as neither2, \
-             cond_contextmgr(path, f"-sites.1.fq{compression}", site_count, filt) as sites1, \
-             cond_contextmgr(path, f"-sites.2.fq{compression}", site_count, filt) as sites2:
+             cond_contextmgr(path, f"-sites.1.fq{compression}", count, filt, use_start_sites) as sites1, \
+             cond_contextmgr(path, f"-sites.2.fq{compression}", count, filt, use_start_sites) as sites2:
             streams = ((host1, host2), (graft1, graft2), (ambiguous1, ambiguous2), (both1, both2), (neither1, neither2), (sites1, sites2))
 
             with ThreadPoolExecutor(max_workers=threads) as executor:
@@ -910,13 +911,12 @@ def compile_classify_read_from_fastq(
     def classify_read_from_fastq_single(fastqs, ht):
         counts = [0, 0, 0, 0, 0, 0]
         nprocessed = 0
-        site_count = count and not use_start_sites
         with cond_contextmgr(path, f"-host.fq{compression}", count, filt) as host, \
              cond_contextmgr(path, f"-graft.fq{compression}", count, filt) as graft, \
              cond_contextmgr(path, f"-ambiguous.fq{compression}", count, filt) as ambiguous, \
              cond_contextmgr(path, f"-both.fq{compression}", count, filt) as both, \
              cond_contextmgr(path, f"-neither.fq{compression}", count, filt) as neither, \
-             cond_contextmgr(path, f"-sites.fq{compression}", site_count, filt) as sites:
+             cond_contextmgr(path, f"-sites.fq{compression}", count, filt, use_start_sites) as sites:
             streams = (host, graft, ambiguous, both, neither, sites)
 
             running_jobs = []

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/xengsort/xengsort_index.py

@@ -211,9 +211,12 @@ def main(args):
 
     startweak = timestamp0(msg="- Computing weak k-mers...")
     nextchars = 3  # TODO:? parameterize via args?
-    calculate_weak_set(
-        h, mask.k, args.groupprefixlength, nextchars,
-        rcmode=rcmode, threads=args.weakthreads)
+    if args.weakthreads > 0:
+        calculate_weak_set(
+            h, mask.k, args.groupprefixlength, nextchars,
+            rcmode=rcmode, threads=args.weakthreads)
+    else:
+        debugprint0('- WARNING: 0 weak threads provided. No weak k-mers computed.')
     timestamp0(startweak, msg="- weak k-mers: wall time")
     timestamp0(startweak, msg="- weak k-mers: wall time", minutes=True)
 

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/xengsort/xengsort_info.py

@@ -7,7 +7,7 @@ from numba import njit
 
 from ..lowlevel import debug
 from ..srhash import print_statistics
-from ..io.hashio import load_hash, dump_to_datafiles
+from ..io.hashio import load_hash, _export_to_datafiles
 
 
 def print_dict(d, title=None):
@@ -63,7 +63,7 @@ def main(args):
     anyformat = (fmt is not None)
     prefix = args.outprefix
     nvalues = values.NVALUES
-    filterfunc = compile_filter_function(args.filter)
+    filterfunc = compile_filter_function(getattr(args, "filter", None))
     if (prefix is None) and anyformat:
         prefix = args.hashname
     if prefix is not None:
@@ -75,7 +75,7 @@ def main(args):
                 fmt = "native"
             elif fmt == "txt":
                 fmt = "text"
-            written = dump_to_datafiles(h, nvalues, infotup, prefix, fmt, filterfunc)
+            written = _export_to_datafiles(h, nvalues, infotup, prefix, fmt, filterfunc)
         debugprint0(f"- wrote {written} items")
         timestamp0(startout, msg="- done writing data; writing time")
 

{xengsort-2.2.1 → xengsort-2.2.2}/xengsort/xengsort/xengsort_main.py

@@ -53,7 +53,9 @@ def classify(p):
         help="only count reads or read pairs for each class, do not output any FASTQ")
     p.add_argument("--prefetchlevel", metavar="INT",
         type=restricted_number_type("from_0_to_2", int, [(">=", 0), ("<=", 2)]),
-        help="amount of prefetching: none (0), second bucket (1), all buckets (2)")
+        help="amount of prefetching: none (0), second bucket (1), all buckets (2) [classify only]")
+    p.add_argument("--lookahead", metavar="INT", type=int, default=16,
+        help="classify2 only: number of k-mers to prefetch ahead during lookup [16]")
     p.add_argument("--chunksize", "-C", metavar="FLOAT_SIZE_MB", type=float, default=8.0,
         help="chunk size in MB; one chunk is allocated per thread.")
     p.add_argument("--chunkreads", "-R", metavar="INT", type=int,
@@ -146,6 +148,11 @@ SUBCOMMANDS = [
         classify,
         "xengsort_classify", "main",
         [f"{CFGPATH}/classify.yaml", 'config/classify.yaml', 'classify.yaml']),
+    ("classify2",
+        "sort/filter/count FASTQ reads (new producer/consumer pipeline; for comparison)",
+        classify,
+        "classify", "main",
+        [f"{CFGPATH}/classify.yaml", 'config/classify.yaml', 'classify.yaml']),
     ("info",
         "get information about a hash table and dump its data",
         info,
@@ -193,7 +200,7 @@ def get_argument_parser():
             chandler = 'error'
         sp = ArgumentParser(prog=name, description=helptext,
             default_config_files=default_configs)
-        if name in ["classify", "index"]:
+        if name in ["classify", "classify2", "index"]:
             sp.add_argument('--cfg', "--config", action=ActionConfigFile)
         sp.add_argument("--func", default=(module, f_main), help=SUPPRESS)
         f_parser(sp)

{xengsort-2.2.1 → xengsort-2.2.2/xengsort.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xengsort
-Version: 2.2.1
+Version: 2.2.2
 Summary: xenograft sorting of FASTQ reads into five categories: host, graft, both, neither, ambiguous.
 Author-email: Jens Zentgraf <zentgraf@cs.uni-saarland.de>, Sven Rahmann <rahmann@cs.uni-saarland.de>
 License: MIT License
@@ -52,6 +52,7 @@ This tool, xengsort, uses 3-way bucketed Cuckoo hashing to efficiently solve the
 For a description of the method an evaluation on several datasets, please see our
 [article in "Algorithms for Molecular Biology"](https://almob.biomedcentral.com/articles/10.1186/s13015-021-00181-w), or the initial [WABI 2020 publication](https://drops.dagstuhl.de/opus/volltexte/2020/12793/).
 (There was also a [preprint on bioRxiv](https://www.biorxiv.org/content/10.1101/2020.05.14.095604v2).)
+If you use xengsort to sort converted reads (RRBS or WGBS) there is a [bioRxiv preprint](https://www.biorxiv.org/content/10.64898/2026.10.06.756952v1.abstract) available.
 BibTeX entrys for citation can be found at the end of this README file.
 
 In case of problems,
@@ -71,24 +72,23 @@ Thank you!
 
 We here provide an example showing how to run xengsort on a human-captured mouse exome (part of one of the datasets described in the paper).
 This tutorial uses the workflow management system `Snakemake` to run the example.
-This is, however, not necessary to use `xengsort`. 
+This is, however, not necessary to use `xengsort`.
 Please refer to the Usage Guide below to learn how to run `xengsort` on your own data manually.
 
 
 Our software `xengsort` is provided as a Python package.
-For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package. 
+For efficiency, it uses just-in-time compilation provided by the [numba](http://numba.pydata.org/) package.
 We here use the package manager [conda](https://docs.conda.io/en/latest/) to manage Python packages and to use a separate environment for `xengsort`.
 
 
-### Install the conda package manager (miniconda)
-Go to https://docs.conda.io/en/latest/miniconda.html and download the Miniconda installer:
-Choose Python 3.10 (or higher), your operating system, and preferably the 64 bit version.
-Follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it). 
+### Install the conda package manager (conda-forge)
+Go to https://conda-forge.org/download/ and download the conda-forge installer:
+Choose your operating system, follow the instructions of the installer and append the conda executable to your PATH (even if the installer does not recommend it).
 You can let the installer do it, or do it manually by editing your ``.bashrc`` or similar file under Linux or MacOS, or by editing the environment variables under Windows.
 To verify that the installation works, open a new terminal and execute
 ```
-conda --version # ideally 22.9.xx or higher
-python --version # ideally 3.10.xx or higher
+conda --version # ideally 26.9.xx or higher
+python --version # ideally 3.12.xx or higher
 ```
 
 
@@ -122,7 +122,7 @@ within the cloned directory tree.
 
 
 ### Create and activate a conda environment
-To run our software, a [conda](https://docs.conda.io/en/latest/) environment with the required libraries needs to be created.
+To run our software, a [conda](https://conda-forge.org/docs/) environment with the required libraries needs to be created.
 A list of needed libraries is provided in the ``environment.yml`` file in the cloned repository;
 it can be used to create a new environment:
 
@@ -133,7 +133,7 @@ conda env create
 which will create an environment named ``xengsort`` with the required dependencies,
 using the provided ``environment.yml`` file in the same directory.
 
-A more explicit alternative is to run 
+A more explicit alternative is to run
 ```
 conda create --name xengsort -c conda-forge -c bioconda --file requirements.txt
 ```
@@ -217,11 +217,11 @@ To build an index for xengsort, several parameters must be provided, which are d
 First, a file name and a path for the index must be chosen.
 The index is stored in two files. We will use `myindex` to store the index in the current folder.
 
-Second, two reference genomes (host and graft) must be provided (in FASTA files). 
-We assume that they are given as `host.fa.gz` and `graft.fa.gz`. 
+Second, two reference genomes (host and graft) must be provided (in FASTA files).
+We assume that they are given as `host.fa.gz` and `graft.fa.gz`.
 The files can be provided as an uncompressed file or compressed using `gzip`, `bzip2` or `xz`.
-The corresponding options are `-H` or `--host` and `-G` or `--graft`. 
-Each option can take several arguments as files. 
+The corresponding options are `-H` or `--host` and `-G` or `--graft`.
+Each option can take several arguments as files.
 ```
 xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 4_500_000_000  [OPTIONS]
 ```
@@ -249,7 +249,7 @@ The final important parameter is about parallelization:
 
 Most of the parameters can also be provided in a config file (`.yaml`):
 - `--cfg` or `--config` defines the path the the config file.
- 
+
 ### How to classify
 
 To classify a FASTQ sample (one or several single-end or paired-end files), make sure you are in an environment where xengsort and its dependencies are installed.
@@ -257,7 +257,7 @@ Then run the `xengsort classify` command with a previously built index, such as
 ```
 xengsort classify --index myindex --fastq single.fq.gz --prefix myresults --mode count
 ```
-for single-end reads, or 
+for single-end reads, or
 ```
 xengsort classify --index myindex --fastq paired.1.fq.gz --pairs paired.2.fq.gz --prefix myresults --mode count
 ```
@@ -275,7 +275,7 @@ The parameter `--prefix` or equivalently `--out` is required and defines the pre
   - `{prefix}.both.1.fq.gz`: reads that could originate from both
   - `{prefix}.neither.1.fq.gz`: reads that originate from neither host nor graft
   - `{prefix}.ambiguous.1.fq.gz`: (few) ambiguous reads that cannot be classified,
-  
+
   and similarly with `.2.fq.gz`. For single-end reads, there is only `.fq.gz` (no numbers).
 
 The compression type can be specified using the `--compression` parameter.
@@ -301,7 +301,7 @@ xengsort index --index myindex -H host.fa.gz -G graft.fa.gz -n 9_000_000_000 --b
 If an index is build using the bisulfite parameter, also the read is converted in the classification step.
 It is not necessary to change the parameters of the classification step.
 Currently, it only supports the count-based classification.
-
+A detailed description on how the benchmarks on bisulfite sequencing data was performed can be found [here](https://github.com/S-Altend/MethSortBench/tree/main/03_read_sorting).
 
 Please report a [GitLab issue](https://gitlab.com/genomeinformatics/xengsort/-/issues) in case of problems.
 
@@ -315,13 +315,13 @@ Happy sorting!
 *  **Snakemake throws errors when attempting to download the example dataset from SRA**.
 
 This may happen for several reasons:
-  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files. 
+  1. The dataset is quite large, over 20 GB. Make sure you have sufficient space (also temporary space) and sufficient disk quota (on a shared system) to store all of the files.
   1. Another source of trouble may be that for some reason and older version of `sra-tools` gets called. We use the `fasterq-dump` tool to download the data, which did not exist in older verisons. To use a clean environment with a recent version of `sra-tools`, you can run snakemake as `snakemake -j 16 --use-conda`, which will generate a separate environment only for the download (this takes additional time, but may resolve the problem).
   1. In earlier versions, the dataset was downloaded from a different location which is no longer available. Please check that you are using at least v1.1.0 (`xengsort --version`). If not, please do a fresh clone and follow the tutorial to set up a new environment (delete the old one first) and run `pip install -e .`, as explained above in the tutorial.
 
 *  **Indexing stops after a few seconds with a failure.**
 
-The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter). 
+The most likely cause of this is that you have not specified the size of the hash table (`-n` parameter).
 (From version 1.0.1, the `-n` parameter is required, and the error cannot occur anymore. Please update to the latest version!)
 For the human and mouse genomes this is approximately `-n 4_500_000_000` (4.5 billion).
 It is unfortunately a limitation of the implementation that the hash table size has to be specified in advance.
@@ -377,3 +377,14 @@ In addition, you may also cite the WABI 2020 proceedigs paper:
   annote =	{Keywords: xenograft sorting, alignment-free method, Cuckoo hashing, k-mer}
 }
 ```
+
+If you use xengsort to sort converted reads, please also cite our corresponding bioRxiv preprint:
+```
+@article {Altendorfer2026.10.06.756952,
+  author = {Altendorfer, Stefan and Zentgraf, Jens and Schmitz, Johanna Elena and Plass, Christoph and Gerh{\"a}user, Clarissa and Rahmann, Sven},
+  title = {High-performance xenograft read-sorting for DNA methylation analysis},
+  year = {2026},
+  doi = {10.64898/2026.10.06.756952},
+  journal = {bioRxiv}
+}
+```