From 5a1cc76dac8e20d933915b7c305aabbd800ceb36 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 7 Apr 2022 06:48:38 -0400 Subject: [PATCH 01/52] restrict fixes * handle empty chromosomes, resolved https://github.com/open2c/pairtools/issues/76 * fixed rfrags indexing and first rfrag omission, resolved https://github.com/open2c/pairtools/issues/73 * resolved or deprecated https://github.com/open2c/pairtools/issues/16 * pairtools restrct tests --- pairtools/pairtools_restrict.py | 39 +++++++++++++++--------- tests/data/mock.rsites.bed | 5 +++ tests/data/mock.test-restr.pairs | 18 +++++++++++ tests/test_restrict.py | 52 ++++++++++++++++++++++++++++++++ 4 files changed, 100 insertions(+), 14 deletions(-) create mode 100644 tests/data/mock.rsites.bed create mode 100644 tests/data/mock.test-restr.pairs create mode 100644 tests/test_restrict.py diff --git a/pairtools/pairtools_restrict.py b/pairtools/pairtools_restrict.py index 3b69c855..ca1e8580 100644 --- a/pairtools/pairtools_restrict.py +++ b/pairtools/pairtools_restrict.py @@ -4,6 +4,7 @@ import sys import click import subprocess +import warnings import numpy as np @@ -14,7 +15,7 @@ @cli.command() @click.argument( - 'pairs_path', + 'pairs_path', type=str, required=False) @@ -26,9 +27,9 @@ '(chrom, start, end). Can be generated using cooler digest.') @click.option( - '-o', "--output", - type=str, - default="", + '-o', "--output", + type=str, + default="", help='output .pairs/.pairsam file.' ' If the path ends with .gz/.lz4, the output is compressed by bgzip/lz4c.' ' By default, the output is printed into stdout.') @@ -40,20 +41,22 @@ def restrict(pairs_path, frags, output, **kwargs): Identify the restriction fragments that got ligated into a Hi-C molecule. - PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz/.lz4, the + Note: rfrags are 0-indexed + + PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. ''' restrict_py(pairs_path, frags, output, **kwargs) def restrict_py(pairs_path, frags, output, **kwargs): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = (_fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) + command=kwargs.get('cmd_in', None)) if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + outstream = (_fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + command=kwargs.get('cmd_out', None)) if output else sys.stdout) @@ -73,15 +76,13 @@ def restrict_py(pairs_path, frags, output, **kwargs): names=['chrom', 'start', 'end']) - rfrags.sort(order=['chrom', 'start','end']) rfrags.sort(order=['chrom', 'start', 'end']) chrom_borders = np.r_[0, 1+np.where(rfrags['chrom'][:-1] != rfrags['chrom'][1:])[0], rfrags.shape[0]] - rfrags = {rfrags['chrom'][i]:rfrags['end'][i:j] +1 + rfrags = { rfrags['chrom'][i] : np.concatenate([[0], rfrags['end'][i:j] + 1]) for i, j in zip(chrom_borders[:-1], chrom_borders[1:])} - for line in body_stream: cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) chrom1, pos1 = cols[_pairsam_format.COL_C1], int(cols[_pairsam_format.COL_P1]) @@ -100,8 +101,18 @@ def restrict_py(pairs_path, frags, output, **kwargs): def find_rfrag(rfrags, chrom, pos): - rsites_chrom = rfrags[chrom] - idx = min(max(0,rsites_chrom.searchsorted(pos, 'right')-1), len(rsites_chrom)-2) + + # Return empty if chromosome is unmapped: + if chrom==_pairsam_format.UNMAPPED_CHROM: + return _pairsam_format.UNANNOTATED_RFRAG, _pairsam_format.UNMAPPED_POS, _pairsam_format.UNMAPPED_POS + + try: + rsites_chrom = rfrags[chrom] + except ValueError as e: + warnings.warn(f"Chomosome {chrom} does not have annotated restriction fragments, return empty.") + return _pairsam_format.UNANNOTATED_RFRAG, _pairsam_format.UNMAPPED_POS, _pairsam_format.UNMAPPED_POS + + idx = min( max(0, rsites_chrom.searchsorted(pos, 'right')-1), len(rsites_chrom)-2) return idx, rsites_chrom[idx], rsites_chrom[idx+1] if __name__ == '__main__': diff --git a/tests/data/mock.rsites.bed b/tests/data/mock.rsites.bed new file mode 100644 index 00000000..6ea6d5cb --- /dev/null +++ b/tests/data/mock.rsites.bed @@ -0,0 +1,5 @@ +chr1 0 100 +chr1 100 500 +chr1 500 10000 +chr2 0 200 +chr2 200 10000 diff --git a/tests/data/mock.test-restr.pairs b/tests/data/mock.test-restr.pairs new file mode 100644 index 00000000..cddda087 --- /dev/null +++ b/tests/data/mock.test-restr.pairs @@ -0,0 +1,18 @@ +## pairs format v1.0.0 +#shape: upper triangle +#genome_assembly: unknown +#samheader: @SQ SN:chr1 LN:10000 +#samheader: @SQ SN:chr2 LN:10000 +#samheader: @PG ID:bwa PN:bwa VN:0.7.15-r1140 CL:bwa mem -SP /path/ucsc.hg19.fasta.gz /path/1.fastq.gz /path/2.fastq.gz +#chromosomes: chr1 chr2 +#chromsize: chr1 10000 +#chromsize: chr2 10000 +#columns: readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type rfrag_test1 rfrag_test2 +readid01 chr1 1 chr2 20 + + UU 0 0 +readid02 chr1 100 chr2 20 - + UU 0 0 +readid03 chr1 100 chr2 20 + + UU 0 0 +readid04 chr1 499 chr2 20 + + UU 1 0 +readid05 chr1 600 chr2 20 + + UU 2 0 +readid06 chr1 1 chr2 200 + + UU 0 0 +readid07 chr1 1 chr2 500 + + UU 0 1 +readid08 chr1 10001 chr2 10001 + + UU 2 1 diff --git a/tests/test_restrict.py b/tests/test_restrict.py new file mode 100644 index 00000000..eaae59ea --- /dev/null +++ b/tests/test_restrict.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +import os +import sys + +from nose.tools import assert_raises + +import subprocess + +testdir = os.path.dirname(os.path.realpath(__file__)) + +def test_restrict(): + """Restrict pairs file""" + mock_pairs_path = os.path.join(testdir, "data", "mock.test-restr.pairs") + mock_rfrag_path = os.path.join(testdir, "data", "mock.rsites.bed") + try: + result = subprocess.check_output( + [ + "python", + "-m", + "pairtools", + "restrict", + "-f", + mock_rfrag_path, + mock_pairs_path, + ], + ).decode("ascii") + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check if the header got transferred correctly + true_header = [l.strip() for l in open(mock_pairs_path, "r") if l.startswith("@")] + output_header = [l.strip() for l in result.split("\n") if l.startswith("#")] + for l in true_header: + assert any([l in l2 for l2 in output_header]) + + # check that the pairs got assigned properly + cols = [x for x in output_header if x.startswith('#columns')][0].split(' ')[1:] + + COL_RFRAG1_TRUE = cols.index('rfrag_test1') + COL_RFRAG2_TRUE = cols.index('rfrag_test2') + COL_RFRAG1_OUTPUT = cols.index('rfrag1') + COL_RFRAG2_OUTPUT = cols.index('rfrag2') + + for l in result.split("\n"): + if l.startswith("#") or not l: + continue + + line = l.split() + assert line[COL_RFRAG1_TRUE] == line[COL_RFRAG1_OUTPUT] + assert line[COL_RFRAG2_TRUE] == line[COL_RFRAG2_OUTPUT] From 7480fb500a3d4db2c43ea9d98f4c65764c68a1e5 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 7 Apr 2022 07:25:38 -0400 Subject: [PATCH 02/52] pairtools flip fix for unannotated chromosomes, resolving https://github.com/open2c/pairtools/issues/91 --- pairtools/pairtools_flip.py | 24 +++++++++++++++++++----- tests/data/mock.4flip.pairs | 18 +++++++++++------- tests/test_flip.py | 4 +++- 3 files changed, 33 insertions(+), 13 deletions(-) diff --git a/pairtools/pairtools_flip.py b/pairtools/pairtools_flip.py index 3352490b..552500cf 100644 --- a/pairtools/pairtools_flip.py +++ b/pairtools/pairtools_flip.py @@ -2,6 +2,7 @@ import click from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +import warnings UTIL_NAME = 'pairtools_flip' @@ -95,11 +96,24 @@ def flip_py( for line in body_stream: cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) - has_correct_order = ( - (chrom_enum[cols[chrom1_col]], int(cols[pos1_col])) - <= (chrom_enum[cols[chrom2_col]], int(cols[pos2_col])) - ) - + is_annotated1 = cols[chrom1_col] in chrom_enum.keys() + is_annotated2 = cols[chrom2_col] in chrom_enum.keys() + if not is_annotated1 or not is_annotated2: + warnings.warn(f"Unannotated chromosomes in the pairs file!") + # Flip so that annotated chromosome stands first: + if is_annotated1 and not is_annotated2: + has_correct_order = True + elif is_annotated2 and not is_annotated1: + has_correct_order = False + elif not is_annotated1 and not is_annotated2: + has_correct_order = cols[chrom1_col] Date: Fri, 8 Apr 2022 08:19:03 -0400 Subject: [PATCH 03/52] merge improvements, header merge fixed - resolved https://github.com/open2c/pairtools/issues/61 - option to add only the first header in merge, resolved https://github.com/open2c/pairtools/issues/18 --- pairtools/_headerops.py | 16 +++++++++++----- pairtools/pairtools_merge.py | 17 ++++++++++++++--- tests/test_merge.py | 31 ++++++++++++++++++++++++++++--- 3 files changed, 53 insertions(+), 11 deletions(-) diff --git a/pairtools/_headerops.py b/pairtools/_headerops.py index 0d0cf4fa..e0626082 100644 --- a/pairtools/_headerops.py +++ b/pairtools/_headerops.py @@ -276,9 +276,8 @@ def _add_pg_to_samheader(samheader, ID="", PN="", VN=None, CL=None, force=False) ------- new_header : list of str A list of new headers lines, stripped of newline characters. - - """ + if VN is None: VN = __version__ if CL is None: @@ -466,6 +465,7 @@ def merge_chrom_lists(*lsts): chrom_list = list(_toposort(g.copy(), tie_breaker=min)) if sentinel in chrom_list: chrom_list.remove(sentinel) + chrom_list = sorted(chrom_list) return chrom_list @@ -548,6 +548,8 @@ def _merge_pairheaders(pairheaders, force=False): "#columns:", ] + keys_orginal = [l.split()[0] for header in pairheaders for l in header] + for k in keys_expected_identical: lines = [[l for l in header if l.startswith(k)] for header in pairheaders] same = all([l == lines[0] for l in lines]) @@ -571,10 +573,14 @@ def _merge_pairheaders(pairheaders, force=False): chrom_lists.append(chromlist) chroms_merged = merge_chrom_lists(*chrom_lists) - chrom_lines = [ + if "#chromosomes:" in keys_orginal: + chrom_line = "#chromosomes: {}".format(" ".join(chroms_merged)) + new_header.extend([chrom_line]) + + chromsize_lines = [ "#chromsize: {} {}".format(chrom, chromsizes[chrom]) for chrom in chroms_merged ] - new_header.extend(chrom_lines) + new_header.extend(chromsize_lines) # finally, add a sorted list of other unique fields other_lines = sorted( @@ -583,7 +589,7 @@ def _merge_pairheaders(pairheaders, force=False): for h in pairheaders for l in h if not any( - l.startswith(k) for k in keys_expected_identical + ["#chromsize"] + l.startswith(k) for k in keys_expected_identical + ["#chromosomes", "#chromsize"] ) ) ) diff --git a/pairtools/pairtools_merge.py b/pairtools/pairtools_merge.py index d441ff19..b6a874ef 100644 --- a/pairtools/pairtools_merge.py +++ b/pairtools/pairtools_merge.py @@ -46,7 +46,6 @@ default='2G', show_default=True, help='The amount of memory used by default.', - ) @click.option( @@ -102,7 +101,12 @@ 'Must read input from stdin and print output into stdout. ' 'EXAMPLE: pbgzip -c -n 8' ) - +@click.option( + "--keep-first-header/--no-keep-first-header", + default=False, + show_default=True, + help='Keep the first header or merge the headers together. Default: merge headers.', + ) # Using custom IO options def merge(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs): @@ -126,7 +130,10 @@ def merge(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, npro def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs): paths = sum([glob.glob(mask) for mask in pairs_path], []) - outstream = (_fileio.auto_open(output, mode='w', + if len(paths)==0: + raise ValueError(f"No input paths: {pairs_path}") + + outstream = (_fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), command=kwargs.get('cmd_out', None)) if output else sys.stdout) @@ -151,6 +158,10 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n h, _ = _headerops.get_header(f) headers.append(h) f.close() + # Skip other headers if keep_first_header is True (False by default): + if kwargs.get('keep_first_header', False): + break + merged_header = _headerops.merge_headers(headers) merged_header = _headerops.append_new_pg( merged_header, ID=UTIL_NAME, PN=UTIL_NAME) diff --git a/tests/test_merge.py b/tests/test_merge.py index 54dfab02..96abacbe 100644 --- a/tests/test_merge.py +++ b/tests/test_merge.py @@ -63,9 +63,9 @@ def test_mock_pairsam(): raise e # check that all pairsam entries survived sorting: - pairsam_body_1 = [l.strip() for l in open(mock_pairsam_path_1, 'r') + pairsam_body_1 = [l.strip() for l in open(mock_pairsam_path_1, 'r') if not l.startswith('#') and l.strip()] - pairsam_body_2 = [l.strip() for l in open(mock_pairsam_path_2, 'r') + pairsam_body_2 = [l.strip() for l in open(mock_pairsam_path_2, 'r') if not l.startswith('#') and l.strip()] output_body = [l.strip() for l in result.split('\n') if not l.startswith('#') and l.strip()] @@ -80,10 +80,35 @@ def test_mock_pairsam(): if (cur_pair[0] == prev_pair[0]): assert (cur_pair[1] >= prev_pair[1]) if (cur_pair[1] == prev_pair[1]): - assert (cur_pair[2] >= prev_pair[2]) + assert (cur_pair[2] >= prev_pair[2]) if (cur_pair[2] == prev_pair[2]): assert (cur_pair[3] >= prev_pair[3]) prev_pair = cur_pair + # Check that the header is preserved: + try: + result = subprocess.check_output( + ['python', + '-m', + 'pairtools', + 'merge', + '--keep-first-header', + mock_sorted_pairsam_path_1, + mock_sorted_pairsam_path_2 + ], + ).decode('ascii') + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check the headers: + pairsam_header_1 = [l.strip() for l in open(mock_sorted_pairsam_path_1, 'r') + if l.startswith('#') and l.strip()] + pairsam_header_2 = [l.strip() for l in open(mock_sorted_pairsam_path_2, 'r') + if l.startswith('#') and l.strip()] + output_header = [l.strip() for l in result.split('\n') + if l.startswith('#') and l.strip()] + assert len(pairsam_header_1)+1 == len(output_header) \ No newline at end of file From 4feda3a13fa26879181ce970cbcd6c5ebbc9eb3b Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Fri, 8 Apr 2022 08:44:12 -0400 Subject: [PATCH 04/52] merge improvements * in merge, added option to concatenate instead of merge sorted inputs, resolving: https://github.com/open2c/pairtools/issues/23 * merge checks that columns of inputs are the same --- pairtools/_headerops.py | 7 ++++ pairtools/pairtools_merge.py | 68 ++++++++++++++++++++++-------------- 2 files changed, 49 insertions(+), 26 deletions(-) diff --git a/pairtools/_headerops.py b/pairtools/_headerops.py index e0626082..f6fc4b22 100644 --- a/pairtools/_headerops.py +++ b/pairtools/_headerops.py @@ -602,6 +602,13 @@ def _merge_pairheaders(pairheaders, force=False): return new_header +def all_same_columns(pairheaders): + key_target = "#columns:" + lines = [[l for l in header if l.startswith(key_target)] for header in pairheaders] + all_same = all([l == lines[0] for l in lines]) + return all_same + + def merge_headers(headers, force=False): samheaders, pairheaders = zip( *[extract_fields(h, "samheader", save_rest=True) for h in headers] diff --git a/pairtools/pairtools_merge.py b/pairtools/pairtools_merge.py index b6a874ef..73d9cb29 100644 --- a/pairtools/pairtools_merge.py +++ b/pairtools/pairtools_merge.py @@ -107,10 +107,17 @@ show_default=True, help='Keep the first header or merge the headers together. Default: merge headers.', ) +@click.option( + "--concatenate/--no-concatenate", + default=False, + show_default=True, + help='Simple concatenate instead of merging sorted files.', + ) # Using custom IO options def merge(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs): - """Merge sorted .pairs/.pairsam files. + """Merge .pairs/.pairsam files. + By default, assumes that the files are sorted and maintains the sorting. Merge triu-flipped sorted pairs/pairsam files. If present, the @SQ records of the SAM header must be identical; the sorting order of @@ -162,37 +169,46 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n if kwargs.get('keep_first_header', False): break + if not _headerops.all_same_columns(headers): + raise ValueError("Input pairs cannot contain different columns") + merged_header = _headerops.merge_headers(headers) merged_header = _headerops.append_new_pg( merged_header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l+'\n' for l in merged_header)) outstream.flush() - - command = r''' - /bin/bash -c 'export LC_COLLATE=C; export LANG=C; sort - -k {0},{0} -k {1},{1} -k {2},{2}n -k {3},{3}n -k {4},{4} - --merge - --field-separator=$'\''{5}'\'' - {6} - {7} - {8} - -S {9} - {10} - '''.replace('\n',' ').format( - _pairsam_format.COL_C1+1, - _pairsam_format.COL_C2+1, - _pairsam_format.COL_P1+1, - _pairsam_format.COL_P2+1, - _pairsam_format.COL_PTYPE+1, - _pairsam_format.PAIRSAM_SEP_ESCAPE, - ' --parallel={} '.format(nproc) if nproc > 1 else ' ', - ' --batch-size={} '.format(max_nmerge) if max_nmerge else ' ', - ' --temporary-directory={} '.format(tmpdir) if tmpdir else ' ', - memory, - (' --compress-program={} '.format(compress_program) - if compress_program else ' '), - ) + + # If concatenation requested instead of merging sorted input: + if kwargs.get('concatenate', False): + command = r''' + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat ''' + # Full merge that keeps the ordered input: + else: + command = r''' + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; sort + -k {0},{0} -k {1},{1} -k {2},{2}n -k {3},{3}n -k {4},{4} + --merge + --field-separator=$'\''{5}'\'' + {6} + {7} + {8} + -S {9} + {10} + '''.replace('\n',' ').format( + _pairsam_format.COL_C1+1, + _pairsam_format.COL_C2+1, + _pairsam_format.COL_P1+1, + _pairsam_format.COL_P2+1, + _pairsam_format.COL_PTYPE+1, + _pairsam_format.PAIRSAM_SEP_ESCAPE, + ' --parallel={} '.format(nproc) if nproc > 1 else ' ', + ' --batch-size={} '.format(max_nmerge) if max_nmerge else ' ', + ' --temporary-directory={} '.format(tmpdir) if tmpdir else ' ', + memory, + (' --compress-program={} '.format(compress_program) + if compress_program else ' '), + ) for path in paths: if kwargs.get('cmd_in', None): command += r''' <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')'''.format(path, kwargs['cmd_in']) From b002dbe19a0ffd914ee5790ec8cdc7978dc863c0 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Fri, 8 Apr 2022 10:38:22 -0400 Subject: [PATCH 05/52] I/O improvement - auto_open defaults to stdin/stdout when path evaluates to False. resolved https://github.com/open2c/pairtools/issues/48 - auto_open defaults to stdin/stdout when the path is "-" - if the stream is optional, it's controlled by the module itself Warning: this might be unstable because not all the usecases were tested! --- pairtools/_fileio.py | 11 ++++++-- pairtools/pairtools_markasdup.py | 8 ++---- pairtools/pairtools_merge.py | 5 ++-- pairtools/pairtools_parse.py | 47 ++++++++++---------------------- pairtools/pairtools_phase.py | 10 +++---- pairtools/pairtools_restrict.py | 6 ++-- pairtools/pairtools_sample.py | 10 +++---- pairtools/pairtools_select.py | 43 +++++++++++++++-------------- pairtools/pairtools_sort.py | 10 +++---- pairtools/pairtools_split.py | 32 +++++++++++----------- pairtools/pairtools_stats.py | 26 ++++-------------- tests/test_parse.py | 1 + tests/test_select.py | 1 - 13 files changed, 89 insertions(+), 121 deletions(-) diff --git a/pairtools/_fileio.py b/pairtools/_fileio.py index c2d74bf7..81d5f663 100644 --- a/pairtools/_fileio.py +++ b/pairtools/_fileio.py @@ -1,7 +1,7 @@ import shutil import pipes import subprocess - +import sys class ParseError(Exception): pass @@ -23,6 +23,14 @@ def auto_open(path, mode, nproc=1, command=None): .gz - pbgzip if available, otherwise bgzip .lz4 - lz4c (does not support parallel execution) ''' + + # Empty filepath or False provided + if not path or path=="-": + if mode=="r": + return sys.stdin + if mode=="w": + return sys.stdout + if command: if mode =='w': t = pipes.Template() @@ -135,7 +143,6 @@ def auto_open(path, mode, nproc=1, command=None): return open(path, mode) - class PipedIO: def __init__(self, file_or_path, command, mode='r'): """ diff --git a/pairtools/pairtools_markasdup.py b/pairtools/pairtools_markasdup.py index 0176f2d4..61c26c07 100644 --- a/pairtools/pairtools_markasdup.py +++ b/pairtools/pairtools_markasdup.py @@ -35,14 +35,12 @@ def markasdup(pairsam_path, output, **kwargs): markasdup_py(pairsam_path, output, **kwargs) def markasdup_py(pairsam_path, output, **kwargs): - instream = (_fileio.auto_open(pairsam_path, mode='r', + instream = _fileio.auto_open(pairsam_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairsam_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + command=kwargs.get('cmd_in', None)) + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), command=kwargs.get('cmd_out', None)) - if output else sys.stdout) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) diff --git a/pairtools/pairtools_merge.py b/pairtools/pairtools_merge.py index 73d9cb29..340fcf0f 100644 --- a/pairtools/pairtools_merge.py +++ b/pairtools/pairtools_merge.py @@ -140,10 +140,9 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n if len(paths)==0: raise ValueError(f"No input paths: {pairs_path}") - outstream = (_fileio.auto_open(output, mode='w', + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) + command=kwargs.get('cmd_out', None)) # if there is only one input, bypass merging and do not modify the header if len(paths) == 1: diff --git a/pairtools/pairtools_parse.py b/pairtools/pairtools_parse.py index 72d009b9..18e0ef7c 100644 --- a/pairtools/pairtools_parse.py +++ b/pairtools/pairtools_parse.py @@ -231,36 +231,19 @@ def parse_py( input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get('nproc_in')) ### Set up output streams - outstream = ( - _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout - ) - out_alignments_stream = ( - _fileio.auto_open( - output_parsed_alignments, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output_parsed_alignments - else None - ) - out_stats_stream = ( - _fileio.auto_open( - output_stats, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output_stats - else None - ) + outstream = _fileio.auto_open(output, mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None)) + + out_alignments_stream, out_stats_stream = None, None + if output_parsed_alignments: + out_alignments_stream = _fileio.auto_open(output_parsed_alignments, mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None)) + if output_stats: + out_stats_stream = _fileio.auto_open(output_stats, mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None)) if out_alignments_stream: out_alignments_stream.write( @@ -335,9 +318,9 @@ def parse_py( if outstream != sys.stdout: outstream.close() # close optional output streams if needed: - if out_alignments_stream: + if out_alignments_stream and out_alignments_stream != sys.stdout: out_alignments_stream.close() - if out_stats_stream: + if out_stats_stream and out_stats_stream != sys.stdout: out_stats_stream.close() diff --git a/pairtools/pairtools_phase.py b/pairtools/pairtools_phase.py index 4fc20b18..122d3fee 100644 --- a/pairtools/pairtools_phase.py +++ b/pairtools/pairtools_phase.py @@ -59,14 +59,12 @@ def phase_py( **kwargs ): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = _fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + command=kwargs.get('cmd_in', None)) + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) + command=kwargs.get('cmd_out', None)) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) diff --git a/pairtools/pairtools_restrict.py b/pairtools/pairtools_restrict.py index ca1e8580..ad6192d0 100644 --- a/pairtools/pairtools_restrict.py +++ b/pairtools/pairtools_restrict.py @@ -49,15 +49,13 @@ def restrict(pairs_path, frags, output, **kwargs): restrict_py(pairs_path, frags, output, **kwargs) def restrict_py(pairs_path, frags, output, **kwargs): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = _fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), command=kwargs.get('cmd_out', None)) - if output else sys.stdout) header, body_stream = _headerops.get_header(instream) diff --git a/pairtools/pairtools_sample.py b/pairtools/pairtools_sample.py index cdf87688..1a0a650f 100644 --- a/pairtools/pairtools_sample.py +++ b/pairtools/pairtools_sample.py @@ -57,14 +57,12 @@ def sample_py( **kwargs ): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = _fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + command=kwargs.get('cmd_in', None)) + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) + command=kwargs.get('cmd_out', None)) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) diff --git a/pairtools/pairtools_select.py b/pairtools/pairtools_select.py index da054f39..0ad24287 100644 --- a/pairtools/pairtools_select.py +++ b/pairtools/pairtools_select.py @@ -34,12 +34,13 @@ ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' ' By default, such pairs are dropped.') -@click.option( - "--send-comments-to", - type=click.Choice(['selected', 'rest', 'both', 'none']), - default="both", - help="Which of the outputs should receive header and comment lines", - show_default=True) +# Deprecated option to be removed in the future: +# @click.option( +# "--send-comments-to", +# type=click.Choice(['selected', 'rest', 'both', 'none']), +# default="both", +# help="Which of the outputs should receive header and comment lines", +# show_default=True) @click.option( "--chrom-subset", @@ -73,7 +74,7 @@ @common_io_options def select( - condition, pairs_path, output, output_rest, send_comments_to, + condition, pairs_path, output, output_rest, #send_comments_to, chrom_subset, startup_code, type_cast, **kwargs ): @@ -115,29 +116,31 @@ def select( ''' select_py( - condition, pairs_path, output, output_rest, send_comments_to, + condition, pairs_path, output, output_rest, #send_comments_to, chrom_subset, startup_code, type_cast, **kwargs ) def select_py( - condition, pairs_path, output, output_rest, send_comments_to, chrom_subset, + condition, pairs_path, output, output_rest, #send_comments_to, + chrom_subset, startup_code, type_cast, **kwargs ): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = _fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + command=kwargs.get('cmd_in', None)) + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) - outstream_rest = (_fileio.auto_open(output_rest, mode='w', + command=kwargs.get('cmd_out', None)) + + # Optional output created only if requested: + outstream_rest = None + if output_rest: + outstream_rest = _fileio.auto_open(output_rest, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output_rest else None) + command=kwargs.get('cmd_out', None)) wildcard_library = {} def wildcard_match(x, wildcard): @@ -176,7 +179,7 @@ def regex_match(x, regex): if new_chroms is not None: header = _headerops.subset_chroms_in_pairsheader(header, new_chroms) outstream.writelines((l+'\n' for l in header)) - if outstream_rest: + if output_rest: outstream_rest.writelines((l+'\n' for l in header)) column_names = _headerops.extract_column_names(header) @@ -213,7 +216,7 @@ def regex_match(x, regex): if outstream != sys.stdout: outstream.close() - if outstream_rest: + if output_rest and outstream_rest != sys.stdout: outstream_rest.close() if __name__ == '__main__': diff --git a/pairtools/pairtools_sort.py b/pairtools/pairtools_sort.py index b74c7f99..66756251 100644 --- a/pairtools/pairtools_sort.py +++ b/pairtools/pairtools_sort.py @@ -79,14 +79,12 @@ def sort(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): - instream = (_fileio.auto_open(pairs_path, mode='r', + instream = _fileio.auto_open(pairs_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', + command=kwargs.get('cmd_in', None)) + outstream = _fileio.auto_open(output, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) + command=kwargs.get('cmd_out', None)) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) diff --git a/pairtools/pairtools_split.py b/pairtools/pairtools_split.py index 112c46b2..8bf5e287 100644 --- a/pairtools/pairtools_split.py +++ b/pairtools/pairtools_split.py @@ -47,10 +47,9 @@ def split(pairsam_path, output_pairs, output_sam, **kwargs): def split_py(pairsam_path, output_pairs, output_sam, **kwargs): - instream = (_fileio.auto_open(pairsam_path, mode='r', + instream = _fileio.auto_open(pairsam_path, mode='r', nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairsam_path else sys.stdin) + command=kwargs.get('cmd_in', None)) # Output streams if (not output_pairs) and (not output_sam): @@ -58,16 +57,17 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): if (output_pairs == '-') and (output_sam == '-'): raise ValueError('Only one output (pairs or sam) can be printed in stdout!') - outstream_pairs = (sys.stdout if (output_pairs=='-') - else (_fileio.auto_open(output_pairs, mode='w', + outstream_pairs = None + outstream_sam = None + + if output_pairs: + outstream_pairs = _fileio.auto_open(output_pairs, mode='w', nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output_pairs else None)) - outstream_sam = (sys.stdout if (output_sam=='-') - else (_fileio.auto_open(output_sam, mode='w', + command=kwargs.get('cmd_out', None)) + if output_sam: + outstream_sam = _fileio.auto_open(output_sam, mode='w', nproc=kwargs.get('nproc_out'), command=kwargs.get('cmd_out', None)) - if output_sam else None)) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) @@ -93,9 +93,9 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): sam2col = _pairsam_format.COL_SAM2 has_sams = True - if outstream_pairs: + if output_pairs: outstream_pairs.writelines((l+'\n' for l in header)) - if outstream_sam: + if output_sam: outstream_sam.writelines( (l[11:].strip()+'\n' for l in header if l.startswith('#samheader:'))) @@ -112,22 +112,22 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): sam1 = cols.pop(sam1col) sam2 = cols.pop(sam2col) - if outstream_pairs: + if output_pairs: # hard-coded tab separator to follow the DCIC pairs standard outstream_pairs.write('\t'.join(cols)) outstream_pairs.write('\n') - if (outstream_sam and has_sams): + if (output_sam and has_sams): for col in (sam1, sam2): if col != '.': for sam_entry in col.split(_pairsam_format.INTER_SAM_SEP): outstream_sam.write(sam_entry.replace(_pairsam_format.SAM_SEP,'\t')) outstream_sam.write('\n') - if outstream_pairs and outstream_pairs != sys.stdout: + if output_pairs and outstream_pairs != sys.stdout: outstream_pairs.close() - if outstream_sam and outstream_sam != sys.stdout: + if output_sam and outstream_sam != sys.stdout: outstream_sam.close() diff --git a/pairtools/pairtools_stats.py b/pairtools/pairtools_stats.py index bfed45c8..8b844fe8 100755 --- a/pairtools/pairtools_stats.py +++ b/pairtools/pairtools_stats.py @@ -44,26 +44,12 @@ def stats_py(input_path, output, merge, **kwargs): do_merge(output, input_path, **kwargs) return - instream = ( - _fileio.auto_open( - input_path[0], - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - if input_path - else sys.stdin - ) - outstream = ( - _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout - ) + instream = _fileio.auto_open(input_path[0], mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None)) + outstream = _fileio.auto_open(output, mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None)) header, body_stream = _headerops.get_header(instream) cols = _headerops.extract_column_names(header) diff --git a/tests/test_parse.py b/tests/test_parse.py index 8f98d426..f91c3495 100644 --- a/tests/test_parse.py +++ b/tests/test_parse.py @@ -47,6 +47,7 @@ def test_mock_pysam(): if l.startswith("#") or not l: continue + print(l) assigned_pair = l.split("\t")[1:8] simulated_pair = l.split("CT:Z:SIMULATED:", 1)[1].split("\031", 1)[0].split(",") print(assigned_pair) diff --git a/tests/test_select.py b/tests/test_select.py index f37d171e..a514453b 100644 --- a/tests/test_select.py +++ b/tests/test_select.py @@ -24,7 +24,6 @@ def test_preserve(): print(sys.exc_info()) raise e - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') if not l.startswith('#') and l.strip()] output_body = [l.strip() for l in result.split('\n') From db465f6585df35dc5f24eae3bef33b26d11270e1 Mon Sep 17 00:00:00 2001 From: agalitsyna Date: Tue, 12 Apr 2022 00:20:16 +0200 Subject: [PATCH 06/52] Parse2 update (#99) (#109) Improved version of parse2 with resolved comments from the previous PR: #96 - Separation of parse and parse2 modules. Parse has an option --walks-policy all, which parses long walks, but always reporting pair orientation and outer positions of 5'-ends, as if each pair was read in paired-end mode independently. Parse2 is specifically designed for long walks, and has options --report-position and --report-orientation, which might be used to report junctions, or reads, or walks. - Parse2 has an option to parse single-end reads, --single-end option, tested on minimap2 output for MC-3C. - Parse2 has the max_fragment_size instead instead of parse's max_molecule_size, which help to determine the overlapping ends of forward and reverse reads. - Recent update simplifies the code: single _parse library used by both parse and parse2, - a number of functions that reduce repetitive code, e.g. push_pair function, - dosctrings and documented structure of _parse library. - Both parse and parse2 have the options to report 5' or 3' ends; to flip alignments according to chromosome coordinate. - Both parse and parse2 have the pysam backend - Improvements of the tests for parse and parse2 - Documentation includes description of various --report-orientation and --report-position cases. --- doc/_static/report-orientation.svg | 128 ++ doc/_static/report-positions.svg | 271 ++++ doc/_static/rescue_modes.svg | 260 ++-- doc/_static/rescue_modes_readthrough.svg | 284 ++-- doc/parsing.rst | 124 +- examples/Test_Parse_Walks/TestCase1.png | Bin 211780 -> 0 bytes examples/Test_Parse_Walks/TestCase2.png | Bin 70672 -> 0 bytes examples/Test_Parse_Walks/TestCase2a.png | Bin 64210 -> 0 bytes examples/Test_Parse_Walks/TestCase3.png | Bin 109662 -> 0 bytes examples/Test_Parse_Walks/TestCase4.png | Bin 56024 -> 0 bytes examples/Test_Parse_Walks/TestCase5.png | Bin 55666 -> 0 bytes .../Test_Parse_Walks/Test_Parse_Walks.ipynb | 673 -------- examples/parse2_demo.ipynb | 1163 ++++++++++++++ pairtools/__init__.py | 1 + pairtools/_headerops.py | 17 + pairtools/_pairsam_format.py | 2 +- pairtools/_parse.py | 1378 ++++++++++------- pairtools/_parse_pysam.pyx | 48 + pairtools/pairtools_parse.py | 171 +- pairtools/pairtools_parse2.py | 333 ++++ tests/data/mock.parse-all.sam | 44 +- tests/data/mock.parse2.sam | 56 + tests/test_parse.py | 3 +- tests/test_parse2.py | 111 ++ 24 files changed, 3383 insertions(+), 1684 deletions(-) create mode 100755 doc/_static/report-orientation.svg create mode 100755 doc/_static/report-positions.svg delete mode 100644 examples/Test_Parse_Walks/TestCase1.png delete mode 100644 examples/Test_Parse_Walks/TestCase2.png delete mode 100644 examples/Test_Parse_Walks/TestCase2a.png delete mode 100644 examples/Test_Parse_Walks/TestCase3.png delete mode 100644 examples/Test_Parse_Walks/TestCase4.png delete mode 100644 examples/Test_Parse_Walks/TestCase5.png delete mode 100644 examples/Test_Parse_Walks/Test_Parse_Walks.ipynb create mode 100644 examples/parse2_demo.ipynb create mode 100644 pairtools/pairtools_parse2.py create mode 100644 tests/data/mock.parse2.sam create mode 100644 tests/test_parse2.py diff --git a/doc/_static/report-orientation.svg b/doc/_static/report-orientation.svg new file mode 100755 index 00000000..c844701c --- /dev/null +++ b/doc/_static/report-orientation.svg @@ -0,0 +1,128 @@ + + + Slice 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + read + + + { + + + walk + + + { + + + pair + + + { + + + deafault for both + parse --walks-policy all + and parse2 + + + junction + + + { + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + --report-orientation + + + \ No newline at end of file diff --git a/doc/_static/report-positions.svg b/doc/_static/report-positions.svg new file mode 100755 index 00000000..71aea174 --- /dev/null +++ b/doc/_static/report-positions.svg @@ -0,0 +1,271 @@ + + + Slice 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + * + + + * + + + * + + + + + + + + + * + + + * + + + * + + + + read + + + { + + + + + + + + + + + + + + + + + + * + + + * + + + * + + + + + + + + + * + + + * + + + * + + + + walk + + + { + + + + + + + + + + + + + + + + + + + * + + + * + + + * + + + + + + + + + * + + + * + + + * + + + + outer + + + { + + + + deafault for + parse --walks-policy all + + + + + + + + + + + + + + + + + + + * + + + * + + + * + + + + + + + + + * + + + * + + + * + + + + junction + + + { + + + + deafult for + parse2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + --report-position + + + \ No newline at end of file diff --git a/doc/_static/rescue_modes.svg b/doc/_static/rescue_modes.svg index d44cf505..31b8842b 100644 --- a/doc/_static/rescue_modes.svg +++ b/doc/_static/rescue_modes.svg @@ -1,140 +1,146 @@ - + Slice 1 - - - - - - - - - - - - - - 3r - - - UU - - - - - - - 2u - - - UU - - - - - - - - - - - + + + + + + + + + + + + + + + 3r + - - - - + + + UU + - - - - - - - - - - - - - - - - - - - + + + + + 2u + - - - - - - + + + UU + - - - - - - + + + + + + + + + + + + + + + - - - + + + + + + + + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + UU + + + all + + + mask + + + 5any, 5unique + + + --walks-policy + + + pair_index: + + + 1l + + + UU + + + 3any, 3unique + + + UU + + + WW + + + ! + + + ! + + + { + - - - - UU - - - all - - - mask - - - 5any, 5unique - - - --walks-policy - - - junction_index - - - 1f - - - UU - - - 3any, 3unique - - - UU - - - WW - - - ! - - - ! - - - { - \ No newline at end of file diff --git a/doc/_static/rescue_modes_readthrough.svg b/doc/_static/rescue_modes_readthrough.svg index 2cf2d01b..2e6da006 100644 --- a/doc/_static/rescue_modes_readthrough.svg +++ b/doc/_static/rescue_modes_readthrough.svg @@ -1,153 +1,187 @@ - + Slice 1 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - + + + + + + - - - - - - + + + + + + - - - - - - - - - - + + + - - - - - - + + + + + + - - - - - - uu + + + + + + + + all - - all + + + + mask - - mask + + + + 5any, 5unique - - 5any, 5unique + + + + --walks-policy - - --walks-policy + + + + pair_index - - junction_index + + + + 1l - - 1f + + + + 2b - - 2b + + + + 3r - - 3r + + + + UU - - uu + + + + UU - - uu + + + + UU - - UU + + + + UU - - 3any, 3unique + + + + 3any, 3unique - - UU + + + + UU - - WW + + + + WW - - ! + + + + ! - - ! + + + + ! - - { + + + + { diff --git a/doc/parsing.rst b/doc/parsing.rst index ca25acfe..a076fd46 100644 --- a/doc/parsing.rst +++ b/doc/parsing.rst @@ -107,64 +107,27 @@ If the read is long enough (e.g. larger than 150 bp), it may contain more than t Molecules like these typically form via multiple ligation events and we call them walks [1]_. The mode of walks reporting is controlled by ``--walks-policy`` parameter of ``pairtools parse``. +You can report all the alignments in the reads by using ``pairtools parse2`` (see :ref:`parse2`). A pair of sequential alignments on a single read is **ligation junction**. Ligation junctions are the Hi-C contacts -that have been directly observed in the experiment. They are reported in lower-case letters if walks policy -is set to ``all`` (default). For details, wee :ref:`section-complex-walks-rescue` - -However, traditional Hi-C pairs do not have direct evidence of ligation +that have been directly observed in the experiment. However, traditional Hi-C pairs do not have direct evidence of ligation because they arise from read pairs that do not necessarily contain ligation junction. To filter out the molecules with complex walks, ``--walks-policy`` can be set to: -- ``mask`` to tag these molecules as type ``WW`` (single ligations are rescued, see :ref:`section-single-ligation-rescue`) , +- ``mask`` to tag these molecules as type ``WW`` (single ligations are rescued, see :ref:`Rescuing single ligations`), - ``5any`` to report the 5'-most alignment on each side, - ``5unique`` to report the 5'-most unique alignment on each side, - ``3any`` to report the 3'-most alignment on each side, -- ``3unique`` to report the 3'-most unique alignment on each side. - - -.. _section-complex-walks-rescue: +- ``3unique`` to report the 3'-most unique alignment on each side, +- ``all`` to report all sequential alignments (complex ligations are rescued, see :ref:`Rescuing complex walks`). -Rescuing complex ligations -------------------------- - -The complex walks are DNA molecules containing more than one ligation junction that may end up in more than one alignment -on forward, reverse, or both reads: +Parse modes for walks: .. figure:: _static/rescue_modes.svg :width: 60 % - :alt: Different modes of reporting complex walks - :align: center - - Different modes of reporting complex walks - -``pairtools parse`` detects such molecules and **rescues** them with ``--walks-policy all``. - -Briefly, the algorithm of complex ligation walks rescue detects all the unique ligation junctions, and do not report -the same junction as a pair multiple times. Importantly, these duplicated pairs might arise when both forward and reverse -reads read through the same ligation junction. However, these cases are successfully merged by ``pairtools parse``: - -.. figure:: _static/rescue_modes_readthrough.svg - :width: 60 % - :alt: Reporing complex walks in case of readthrough + :alt: Parse modes for walks :align: center - Reporing complex walks in case of readthrough - -To restore the sequence of ligation events, there is a special field ``junction_index`` that can be reported as -a separate column of .pair file by setting ``--add-junction-index``. This field contains information on: - -- the order of the junction in the recovered walk, starting from 5'-end of forward read -- type of the junction: - - - "u" - unconfirmed junction, right and left alignments in the pair originate from different reads (forward or reverse). This might be indirect ligation (mediated by other DNA fragments). - - "f" - pair originates from the forward read. This is direct ligation. - - "r" - pair originated from the reverse read. Direct ligation. - - "b" - pair was sequenced at both forward and reverse read. Direct ligation. -With this information, the whole sequence of ligation events can be restored from the .pair file. - - -.. _section-single-ligation-rescue: Rescuing single ligations ------------------------- @@ -209,7 +172,7 @@ walks with three aligments using three criteria: Sometimes, the "inner" alignment on the chimeric side can be non-unique or "null" (i.e. when the unmapped segment is longer than ``--max-inter-align-gap``, -as described in :ref:`section-gaps`). ``pairtools parse`` ignores such alignments +as described in :ref:`Interpreting gaps between alignments`). ``pairtools parse`` ignores such alignments altogether and thus rescues such *walks* as well. .. figure:: _static/read_pair_UR_MorN.png @@ -220,8 +183,6 @@ altogether and thus rescues such *walks* as well. A walk with three alignments get rescued, when the middle alignment is multi- or null. -.. _section-gaps: - Interpreting gaps between alignments ------------------------------------ @@ -247,6 +208,75 @@ longer ones as "null" alignments. The maximal size of ignored *gaps* is set by the ``--max-inter-align-gap`` flag (by default, 20bp). +Rescuing complex walks +------------------------- + +We call the multi-fragment DNA molecule that is formed during Hi-C (or any other chromosome capture with sequencing) a walk. +If the reads are long enough, the right (reverse) read might read through the left (forward) read. +Thus, left read might span multiple ligation junctions of the right read. +The pairs of contacts that overlap between left and right reads are intermolecular duplicates that should be removed. + +If the walk has no more than two different fragments at one side of the read, this can be rescued with simple +``pairtools parse --walks-policy mask``. However, in complex walks (two fragments on both reads or more than two fragments on any side) +you need specialized functionality that will report all the deduplicated pairs in the complex walks. +This is especially relevant if you have the reads length > 100 bp, since more than 20% or all restriction fragments in the genome are then shorter than the read length. +We put together some statistics about number of short restriction fragments for DpnII enzyme: + +======== ================= ================== ================== ================== ================== + Genome #rfrags <50 bp <100 bp <150 bp <175 bp <200 bp +-------- ----------------- ------------------ ------------------ ------------------ ------------------ + hg38 828538 (11.5%) 1452918 (20.2%) 2121479 (29.5%) 2587250 (35.9%) 2992757 (41.6%) + mm10 863614 (12.9%) 1554461 (23.3%) 2236609 (33.5%) 2526150 (37.9%) 2780769 (41.7%) + dm3 65327 (19.6%) 108370 (32.5%) 142662 (42.8%) 156886 (47.1%) 169339 (50.9%) +======== ================= ================== ================== ================== ================== + +Consider the read with overlapping left and right sides: + +.. figure:: _static/rescue_modes_readthrough.svg + :width: 60 % + :alt: Complex walk with overlap + :align: center + +Such molecules are detected and **rescued** them. Briefly, we detects all the unique ligation junctions, +and do not report the same junction as a pair multiple times. + +To rescue complex walks, you may use ``pairtools parse --walks-policy all`` and ``parse2``. +They have slightly different functionalities. + +``pairtools parse --walks-policy all`` is used with regular paired-end Hi-C, when you want +all pairs in the walk to be reported as if they appeared in the sequencing data independently. + +``parse2`` is used with single-end data or when you want to report different mode of orientation or position. +By default, ``parse2`` reports ligation junctions instead of outer ends of the alignmentns. +It may report also the position or orientation of the walk or of individual read. + +The complete guide through the reporting options of ``parse2``: + +.. figure:: _static/report-orientation.svg + :width: 60 % + :alt: parse2 --report-orientation + :align: center + + +.. figure:: _static/report-positions.svg + :width: 60 % + :alt: parse2 --report-position + :align: center + + +To restore the sequence of ligation events, there is a special field ``pair_index`` that you have as +a separate column of .pair file when setting ``--add-pair-index`` option. This field contains information on: + +- the order of the pair in the recovered walk, starting from 5'-end of left read +- type of the pair: + + - "u" - unconfirmed pair, right and left alignments in the pair originate from different reads (left or right). This might be indirect ligation (mediated by other DNA fragments). + - "l" - pair originates from the left read. This is direct ligation. + - "r" - pair originated from the right read. Direct ligation. + - "b" - pair was sequenced at both left and right read. Direct ligation. +With this information, the whole sequence of ligation events can be restored from the .pair file. + + .. [1] Following the lead of `C-walks `_ diff --git a/examples/Test_Parse_Walks/TestCase1.png b/examples/Test_Parse_Walks/TestCase1.png deleted file mode 100644 index 2bfae5ad297525d903fa752d91ea753fa7fa5276..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 211780 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 KwMf|_@c#iFModir diff --git a/examples/Test_Parse_Walks/TestCase2.png b/examples/Test_Parse_Walks/TestCase2.png deleted file mode 100644 index 77f27bc5c24347b6cc03bad3f58cb8e8747588f0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 70672 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 z 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 diff --git a/examples/Test_Parse_Walks/TestCase2a.png b/examples/Test_Parse_Walks/TestCase2a.png deleted file mode 100644 index 1670c63090cfcddc62ba8608ff3e91ee2c194b53..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 64210 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 bv-XEiW$w343Y_Ze;GZ)m4NeqjT@3y|j5W_x diff --git a/examples/Test_Parse_Walks/TestCase4.png b/examples/Test_Parse_Walks/TestCase4.png deleted file mode 100644 index 66abb935cfcf473f44a8621389b825ff72c69b77..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 56024 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 XhXJ`UrB=xf_~+PBJ*^iSmO=jyG>t({ diff --git a/examples/Test_Parse_Walks/TestCase5.png b/examples/Test_Parse_Walks/TestCase5.png deleted file mode 100644 index 7bed417242ee19d5173ca4156625b408b7f9b0af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 55666 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

R_ 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 V<(jdpFL1y=S{irMOH?f){vU{Ny$k>V diff --git a/examples/Test_Parse_Walks/Test_Parse_Walks.ipynb b/examples/Test_Parse_Walks/Test_Parse_Walks.ipynb deleted file mode 100644 index 83bc848a..00000000 --- a/examples/Test_Parse_Walks/Test_Parse_Walks.ipynb +++ /dev/null @@ -1,673 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from pairtools._parse import ends_do_overlap, pairs_do_overlap, rescue_complex_walk" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def report_simple_pairsam(algn1, algn2, add_columns=['pos5', 'pos3']):\n", - " cols = [\n", - " '.',\n", - " algn1['chrom'],\n", - " str(algn1['pos']),\n", - " algn2['chrom'],\n", - " str(algn2['pos']),\n", - " algn1['strand'],\n", - " algn2['strand'],\n", - " algn1['type'] + algn2['type']\n", - " ]\n", - "\n", - " for col in add_columns:\n", - " cols.append(str(algn1.get(col, '')))\n", - " cols.append(str(algn2.get(col, '')))\n", - "\n", - " return(' '.join(cols))" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "max_molecule_size = 500\n", - "allowed_offset = 0" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 1\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 400, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr2 200 chr3 300 + + JJ 200 300 250 350\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 1 inverted\n", - "\n", - "Let's change forward and reverse reads" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "algns2 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns1 = [\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 400, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 chr2 200 - - JJ 400 250 300 200\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 2\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 400, 'pos3': 450, 'strand': '+', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 500, 'pos3': 400, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 chr4 400 + + JJ 300 400 350 450\n", - ". chr2 200 chr3 300 + + JJ 200 300 250 350\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 2 inverted\n", - "\n", - "Let's change forward and reverse reads" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "algns2 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 400, 'pos3': 450, 'strand': '+', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns1 = [\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 500, 'pos3': 400, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 chr2 200 - - JJ 350 250 300 200\n", - ". chr4 400 chr3 300 - - JJ 500 350 400 300\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 2.a\n", - "\n", - "Strands mixed\n", - "\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 450, 'pos3': 400, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 400, 'pos3': 450, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 chr4 400 + - JJ 300 450 350 400\n", - ". chr2 200 chr3 300 - + JJ 250 300 200 350\n", - ". chr1 100 chr2 200 + - JJ 100 250 150 200\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 3\n", - "\n", - "Not an overlap (a walk with mismatch at the end of forward read).\n", - "\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr5', 'pos':500, 'pos5': 550, 'pos3': 500, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': 'chr4', 'pos':400, 'pos5': 500, 'pos3': 400, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr5 500 chr2 200 - - PP 550 250 500 200\n", - ". chr3 300 chr5 500 + - JJ 300 550 350 500\n", - ". chr2 200 chr3 300 + + JJ 200 300 250 350\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n", - ". chr3 300 chr2 200 - - JJ 350 250 300 200\n", - ". chr4 400 chr3 300 - - JJ 500 350 400 300\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 4\n", - "\n", - "Mismapped chimeras are treated as match. There is no need to report too much pairs with mismatches.\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 200, 'pos3': 250, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': 'chr2', 'pos':200, 'pos5': 250, 'pos3': 200, 'strand': '-', 'is_mapped': True, 'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 ! 0 + - JN 300 0 350 0\n", - ". chr2 200 chr3 300 + + JJ 200 300 250 350\n", - ". chr1 100 chr2 200 + + JJ 100 200 150 250\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test case 4.a\n", - "\n", - "Mismapped chimeras are treated as match. What if we introduce more of them?\n", - "\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "algns1 = [\n", - " {'chrom': 'chr1', 'pos':100, 'pos5': 100, 'pos3': 150, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 300, 'pos3': 350, 'strand': '+', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True}\n", - "]\n", - "algns2 = [\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True},\n", - " {'chrom': 'chr3', 'pos':300, 'pos5': 350, 'pos3': 300, 'strand': '-', 'is_mapped': True, 'is_unique': True},\n", - " {'chrom': '!', 'pos':0, 'pos5': 0, 'pos3': 0, 'strand': '-', 'is_mapped': False,'is_unique': True}\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "assert ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset)==1 # Note this difference\n", - "assert ends_do_overlap(algns1[-2], algns2[-1], max_molecule_size, allowed_offset)==0\n", - "assert ends_do_overlap(algns1[-3], algns2[-1], max_molecule_size, allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "assert pairs_do_overlap((algns1[-2], algns1[-1]), (algns2[-2], algns2[-1]), allowed_offset)==0\n", - "assert pairs_do_overlap((algns1[-3], algns1[-2]), (algns2[-2], algns2[-1]), allowed_offset)==1" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - ". chr3 300 ! 0 + - JN 300 0 350 0\n", - ". ! 0 chr3 300 - + NJ 0 300 0 350\n", - ". chr1 100 ! 0 + - JN 100 0 150 0\n" - ] - } - ], - "source": [ - "# SAM reporing format: \n", - "# readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type pos51 pos52 pos31 pos32\n", - "for algn1, algn2, algns1, algns2 in rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset):\n", - " print(report_simple_pairsam(algn1, algn2))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pairtools", - "language": "python", - "name": "pairtools" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.8" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/examples/parse2_demo.ipynb b/examples/parse2_demo.ipynb new file mode 100644 index 00000000..68efb4eb --- /dev/null +++ b/examples/parse2_demo.ipynb @@ -0,0 +1,1163 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/agalicina/anaconda3/envs/test/lib/python3.8/site-packages/proplot/config.py:1454: ProPlotWarning: Rebuilding font cache.\n" + ] + } + ], + "source": [ + "import proplot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare the genome" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Activate bwa and minimap2 plugins for genomepy:\n", + "! genomepy plugins enable bwa\n", + "! genomepy plugins enable minimap2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Install hg38 genome by genomepy:\n", + "! genomepy install hg38" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hg38.blacklist.bed.gz hg38.fa.fai hg38.gaps.bed README.txt\r\n", + "hg38.fa\t\t hg38.fa.sizes index\r\n" + ] + } + ], + "source": [ + "# location of the genome:\n", + "! ls ~/.local/share/genomes/hg38/" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "^C\r\n" + ] + } + ], + "source": [ + "# Copy it to the local folder to simplify the code\n", + "! cp -r ~/.local/share/genomes/hg38 ./" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Digest the genome:\n", + "! cooler digest ./hg38/hg38.fa.sizes ./hg38/hg38.fa DpnII > ./hg38/hg38_DpnII.bed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Long-read Arima example\n", + "\n", + "Comparison os parse and parse2 outputs on 150 bp reads.\n", + "\n", + "Example from [human cell line](https://www.ncbi.nlm.nih.gov/sra/SRX10230900[accn]): SRR13849430" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 1000000 spots for SRR13849430\r\n", + "Written 1000000 spots for SRR13849430\r\n" + ] + } + ], + "source": [ + "# Download test data\n", + "! fastq-dump SRR13849430 --gzip --split-spot --split-3 --minSpotId 0 --maxSpotId 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[M::bwa_idx_load_from_disk] read 0 ALT contigs\n", + "[M::process] read 333334 sequences (50000100 bp)...\n", + "[M::process] read 333334 sequences (50000100 bp)...\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (3287, 41601, 3132, 3247)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1474, 3107, 5770)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14362)\n", + "[M::mem_pestat] mean and std.dev: (3761.23, 2688.41)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18658)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (223, 289, 356)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 622)\n", + "[M::mem_pestat] mean and std.dev: (277.40, 91.07)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 755)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1581, 3288, 5799)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14235)\n", + "[M::mem_pestat] mean and std.dev: (3826.54, 2661.54)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18453)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1390, 3033, 5607)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14041)\n", + "[M::mem_pestat] mean and std.dev: (3665.64, 2669.72)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18258)\n", + "[M::mem_process_seqs] Processed 333334 reads in 341.418 CPU sec, 93.551 real sec\n", + "[M::process] read 333334 sequences (50000100 bp)...\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4098, 45623, 3818, 4052)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1387, 3097, 5547)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13867)\n", + "[M::mem_pestat] mean and std.dev: (3675.38, 2672.89)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18027)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (249, 315, 384)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 654)\n", + "[M::mem_pestat] mean and std.dev: (302.37, 92.23)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 789)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1521, 3113, 5702)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14064)\n", + "[M::mem_pestat] mean and std.dev: (3765.30, 2673.78)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18245)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1503, 3159, 5689)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14061)\n", + "[M::mem_pestat] mean and std.dev: (3747.58, 2673.34)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18247)\n", + "[M::mem_process_seqs] Processed 333334 reads in 343.883 CPU sec, 78.964 real sec\n", + "[M::process] read 333334 sequences (50000100 bp)...\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4528, 42266, 4055, 4429)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1475, 3117, 5749)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14297)\n", + "[M::mem_pestat] mean and std.dev: (3758.22, 2705.83)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18571)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (256, 326, 400)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 688)\n", + "[M::mem_pestat] mean and std.dev: (310.02, 96.45)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 832)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1550, 3273, 5819)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14357)\n", + "[M::mem_pestat] mean and std.dev: (3856.53, 2696.57)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18626)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1487, 3090, 5637)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13937)\n", + "[M::mem_pestat] mean and std.dev: (3733.20, 2679.28)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18087)\n", + "[M::mem_process_seqs] Processed 333334 reads in 385.122 CPU sec, 87.424 real sec\n", + "[M::process] read 333334 sequences (50000100 bp)...\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4076, 37876, 3820, 4047)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1454, 3061, 5610)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13922)\n", + "[M::mem_pestat] mean and std.dev: (3732.19, 2712.64)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18078)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (250, 320, 394)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 682)\n", + "[M::mem_pestat] mean and std.dev: (303.19, 95.64)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 826)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1571, 3307, 5902)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14564)\n", + "[M::mem_pestat] mean and std.dev: (3876.78, 2705.22)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18895)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1447, 3096, 5575)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13831)\n", + "[M::mem_pestat] mean and std.dev: (3720.16, 2684.08)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17959)\n", + "[M::mem_process_seqs] Processed 333334 reads in 455.097 CPU sec, 104.136 real sec\n", + "[M::process] read 333330 sequences (49999500 bp)...\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4818, 38154, 4476, 4786)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1450, 3040, 5635)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14005)\n", + "[M::mem_pestat] mean and std.dev: (3690.60, 2666.10)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18190)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (270, 341, 418)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 714)\n", + "[M::mem_pestat] mean and std.dev: (322.66, 97.78)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 862)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1559, 3229, 5848)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14426)\n", + "[M::mem_pestat] mean and std.dev: (3840.73, 2697.24)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18715)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1469, 3134, 5727)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14243)\n", + "[M::mem_pestat] mean and std.dev: (3761.26, 2703.10)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18501)\n", + "[M::mem_process_seqs] Processed 333334 reads in 354.385 CPU sec, 79.123 real sec\n", + "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4834, 38078, 4440, 4800)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1456, 3150, 5690)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14158)\n", + "[M::mem_pestat] mean and std.dev: (3764.15, 2683.53)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18392)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (271, 342, 422)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 724)\n", + "[M::mem_pestat] mean and std.dev: (323.77, 98.63)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 875)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1653, 3328, 5869)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14301)\n", + "[M::mem_pestat] mean and std.dev: (3897.71, 2667.65)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18517)\n", + "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", + "[M::mem_pestat] (25, 50, 75) percentile: (1471, 3102, 5666)\n", + "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14056)\n", + "[M::mem_pestat] mean and std.dev: (3732.45, 2677.73)\n", + "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18251)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[M::mem_process_seqs] Processed 333330 reads in 326.313 CPU sec, 68.738 real sec\n", + "[main] Version: 0.7.17-r1188\n", + "[main] CMD: bwa mem -t 5 -SP /home/agalicina/.local/share/genomes//hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz\n", + "[main] Real time: 528.991 sec; CPU: 2212.054 sec\n" + ] + } + ], + "source": [ + "# Map test data:\n", + "! bwa mem -t 5 -SP ~/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz > test.bam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run regular parse" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools parse -o test_arima_parse.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", + " --drop-sam --drop-seq --output-stats test_arima_parse.stats \\\n", + " --assembly hg38 --no-flip \\\n", + " --add-columns pos5,pos3 \\\n", + " --walks-policy mask \\\n", + " test.bam " + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRR13849430.1\tchr12\t78795816\t!\t0\t-\t-\tUN\t78795816\t0\t78795720\t0\n", + "SRR13849430.2\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", + "SRR13849430.3\tchr2\t72005391\t!\t0\t+\t-\tUN\t72005391\t0\t72005521\t0\n", + "SRR13849430.4\tchr2\t20530788\t!\t0\t+\t-\tUN\t20530788\t0\t20530937\t0\n", + "SRR13849430.5\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", + "SRR13849430.6\tchr3\t857974\t!\t0\t+\t-\tUN\t857974\t0\t858099\t0\n", + "SRR13849430.7\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", + "SRR13849430.8\tchr19\t40057590\t!\t0\t-\t-\tRN\t40057590\t0\t40057465\t0\n", + "SRR13849430.9\tchr6\t111954600\t!\t0\t-\t-\tRN\t111954600\t0\t111954451\t0\n", + "SRR13849430.10\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n" + ] + } + ], + "source": [ + "%%bash\n", + "gzip -dc test_arima_parse.pairs.gz | grep -v \"#\" | head -n 10 | cat\n", + "# Note that there are now pos5 and pos3 columns:" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "# Read the stats of regular parse:\n", + "stats_parse = pd.read_table('./test_arima_parse.stats', header=None)\n", + "stats_parse.columns = ['stat', 'count']\n", + "stats_parse.set_index('stat', inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 700 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if not 'freq' in x]\n", + "\n", + "plt.figure(figsize=[7, 5])\n", + "stats_parse.loc[columns, 'count'].plot(kind='bar')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run parse2" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Usage: pairtools parse2 [OPTIONS] [SAM_PATH]\n", + "\n", + " Find ligation junctions in .sam, make .pairs. SAM_PATH : an input\n", + " .sam/.bam file with paired-end sequence alignments of Hi-C molecules. If\n", + " the path ends with .bam, the input is decompressed from bam with samtools.\n", + " By default, the input is read from stdin.\n", + "\n", + "Options:\n", + " -c, --chroms-path TEXT Chromosome order used to flip\n", + " interchromosomal mates: path to a\n", + " chromosomes file (e.g. UCSC chrom.sizes or\n", + " similar) whose first column lists scaffold\n", + " names. Any scaffolds not listed will be\n", + " ordered lexicographically following the\n", + " names provided. [required]\n", + "\n", + " --assembly TEXT Name of genome assembly (e.g. hg19, mm10) to\n", + " store in the pairs header.\n", + "\n", + " --min-mapq INTEGER The minimal MAPQ score to consider a read as\n", + " uniquely mapped [default: 1]\n", + "\n", + " --max-inter-align-gap INTEGER read segments that are not covered by any\n", + " alignment and longer than the specified\n", + " value are treated as \"null\" alignments.\n", + " These null alignments convert otherwise\n", + " linear alignments into walks, and affect how\n", + " they get reported as a Hi-C pair. [default:\n", + " 20]\n", + "\n", + " --max-fragment-size INTEGER Largest fragment size for the detection of\n", + " overlapping alignments at the ends of\n", + " forward and reverse reads. Not used in\n", + " --single-end mode. [default: 500]\n", + "\n", + " --single-end If specified, the input is single-end.\n", + " -o, --output-file TEXT output file. If the path ends with .gz or\n", + " .lz4, the output is bgzip-/lz4-compressed.By\n", + " default, the output is printed into stdout.\n", + "\n", + " --coordinate-system [read|walk|pair]\n", + " coordinate system for reporting the walk.\n", + " \"read\" - orient each pair as it appeared on\n", + " a read, starting from 5'-end of forward then\n", + " reverse read. \"walk\" - orient each pair as\n", + " it appeared sequentially in the\n", + " reconstructed walk. \"pair\" - re-orient each\n", + " pair as if it was sequenced independently by\n", + " Hi-C. [default: read]\n", + "\n", + " --no-flip If specified, do not flip pairs in genomic\n", + " order and instead preserve the order in\n", + " which they were sequenced.\n", + "\n", + " --drop-readid If specified, do not add read ids to the\n", + " output\n", + "\n", + " --readid-transform TEXT A Python expression to modify read IDs.\n", + " Useful when read IDs differ between the two\n", + " reads of a pair. Must be a valid Python\n", + " expression that uses variables called readID\n", + " and/or i (the 0-based index of the read pair\n", + " in the bam file) and returns a new value,\n", + " e.g. \"readID[:-2]+'_'+str(i)\". Make sure\n", + " that transformed readIDs remain unique!\n", + "\n", + " --drop-seq If specified, remove sequences and PHREDs\n", + " from the sam fields\n", + "\n", + " --drop-sam If specified, do not add sams to the output\n", + " --add-junction-index If specified, parse2 will report junction\n", + " index for each pair in the walk\n", + "\n", + " --add-columns TEXT Report extra columns describing alignments\n", + " Possible values (can take multiple values as\n", + " a comma-separated list): a SAM tag (any pair\n", + " of uppercase letters) or mapq, pos5, pos3,\n", + " cigar, read_len, matched_bp, algn_ref_span,\n", + " algn_read_span, dist_to_5, dist_to_3, seq.\n", + "\n", + " --output-stats TEXT output file for various statistics of pairs\n", + " file. By default, statistics is not\n", + " generated.\n", + "\n", + " --nproc-in INTEGER Number of processes used by the auto-guessed\n", + " input decompressing command. [default: 3]\n", + "\n", + " --nproc-out INTEGER Number of processes used by the auto-guessed\n", + " output compressing command. [default: 8]\n", + "\n", + " --cmd-in TEXT A command to decompress the input file. If\n", + " provided, fully overrides the auto-guessed\n", + " command. Does not work with stdin. Must read\n", + " input from stdin and print output into\n", + " stdout. EXAMPLE: pbgzip -dc -n 3\n", + "\n", + " --cmd-out TEXT A command to compress the output file. If\n", + " provided, fully overrides the auto-guessed\n", + " command. Does not work with stdout. Must\n", + " read input from stdin and print output into\n", + " stdout. EXAMPLE: pbgzip -c -n 8\n", + "\n", + " -h, --help Show this message and exit.\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Call for help:\n", + "pairtools parse2 -h" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Report pairs as if each one was sequenced independetly (coord system \"pair\")\n", + "pairtools parse2 -o test_arima_parse2.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", + " --drop-sam --drop-seq --output-stats test_arima_parse2.stats \\\n", + " --assembly hg38 --no-flip \\\n", + " --add-columns pos5,pos3 \\\n", + " --add-junction-index \\\n", + " --coordinate-system pair \\\n", + " test.bam" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [], + "source": [ + "stats_parse2 = pd.read_table('./test_arima_parse2.stats', header=None)\n", + "stats_parse2.columns = ['stat', 'count']\n", + "stats_parse2.set_index('stat', inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [], + "source": [ + "stats_parse.loc[:, 'mode'] = 'arima_parse'\n", + "stats_parse2.loc[:, 'mode'] = 'arima_parse2'\n", + "stats_all = pd.concat([stats_parse, stats_parse2])" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if not 'freq' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", + "plt.xticks(rotation=90)\n", + "\n", + "plt.tight_layout()\n", + "# Note the artificial increase in the total number of pairs:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check P(s) for two regimes:" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '++' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '--' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '+-' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '-+' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ~~Restriction at the ends of alignments:~~\n", + "\n", + "tests to be implemented, for now only checks the restriction" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/agalicina/soft/pairtools2/pairtools/pairtools/pairtools_restrict.py:63: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n", + " rfrags = np.genfromtxt(\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Select only UU and RU reads for parse and restrict:\n", + "pairtools select '(pair_type == \"UU\") or (pair_type == \"UR\") or (pair_type == \"RU\")' \\\n", + " -o test_arima_parse.UU.pairs.gz test_arima_parse.pairs.gz\n", + " \n", + "pairtools restrict -f ./hg38/hg38_DpnII.bed -o test_arima_parse.UU.restricted.pairs.gz test_arima_parse.UU.pairs.gz" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/agalicina/soft/pairtools2/pairtools/pairtools/pairtools_restrict.py:63: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n", + " rfrags = np.genfromtxt(\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Select only UU reads for parse2 and restrict:\n", + "pairtools select '(pair_type == \"UU\")' \\\n", + " -o test_arima_parse2.UU.pairs.gz test_arima_parse2.pairs.gz\n", + " \n", + "pairtools restrict -f ./hg38/hg38_DpnII.bed -o test_arima_parse2.UU.restricted.pairs.gz test_arima_parse2.UU.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PacBio single-end example: MC-3C\n", + "\n", + "Single-end PacBio data from MC-3C [GSE146945](https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE146945):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 21359 spots for SRR11304457\r\n", + "Written 21359 spots for SRR11304457\r\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Download test data\n", + "! fastq-dump SRR11304457 --minSpotId 0 --maxSpotId 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[M::main::9.122*0.99] loaded/built the index for 24 target sequence(s)\n", + "[M::mm_mapopt_update::10.979*1.00] mid_occ = 704\n", + "[M::mm_idx_stat] kmer size: 15; skip: 10; is_hpc: 0; #seq: 24\n", + "[M::mm_idx_stat::12.130*1.00] distinct minimizers: 100128525 (38.78% are singletons); average occurrences: 5.526; average spacing: 5.581; total length: 3088269832\n", + "[M::worker_pipeline::94.133*2.71] mapped 21359 sequences\n", + "[M::main] Version: 2.18-r1015\n", + "[M::main] CMD: minimap2 -a ./hg38/index/minimap2/hg38.mmi SRR11304457.fastq\n", + "[M::main] Real time: 94.654 sec; CPU: 255.252 sec; Peak RSS: 8.086 GB\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Align with minimap2: \n", + "minimap2 -a ./hg38/index/minimap2/hg38.mmi SRR11304457.fastq > mc3c-test.sam" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Parse pairs\n", + "pairtools parse2 -o mc3c-test.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", + " --drop-sam --drop-seq --output-stats mc3c-test_parse2.stats \\\n", + " --assembly hg38 --no-flip \\\n", + " --add-columns pos5,pos3 \\\n", + " --add-junction-index \\\n", + " --coordinate-system pair \\\n", + " --single-end \\\n", + " mc3c-test.sam" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parse the stats table and compare with Arima. It two capture methods are inline with each other, this is a good sign:" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "# Read the table\n", + "stats_mc3c = pd.read_table('./mc3c-test_parse2.stats', header=None)\n", + "stats_mc3c.columns = ['stat', 'count']\n", + "stats_mc3c.set_index('stat', inplace=True)\n", + "stats_mc3c.loc[:, 'mode'] = 'mc3c'" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [], + "source": [ + "# Columns with normalizaed data to make Arima and MC3C datasets comparable:\n", + "stats_mc3c.loc[:, 'norm_counts'] = 100*stats_mc3c['count']/stats_mc3c.loc['total_nodups', 'count']\n", + "stats_parse.loc[:, 'norm_counts'] = 100*stats_parse['count']/stats_parse.loc['total_nodups', 'count']\n", + "stats_parse2.loc[:, 'norm_counts'] = 100*stats_parse2['count']/stats_parse2.loc['total_nodups', 'count']" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [], + "source": [ + "stats_all = pd.concat([stats_parse, stats_parse2, stats_mc3c])" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if not 'freq' in x][5:]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='norm_counts', x='stat', hue='mode')\n", + "plt.xticks(rotation=90)\n", + "plt.title('Percentage of different types of pairs normalized to total nodups (%)')\n", + "plt.tight_layout()\n", + "\n", + "# Note increase in trans interactions for MC3C:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check P(s) for three regimes:" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "metadata": {}, + "outputs": [], + "source": [ + "stats_mc3c.loc[:, 'cis_norm_counts'] = 100*stats_mc3c['count']/stats_mc3c.loc['cis', 'count']\n", + "stats_parse.loc[:, 'cis_norm_counts'] = 100*stats_parse['count']/stats_parse.loc['cis', 'count']\n", + "stats_parse2.loc[:, 'cis_norm_counts'] = 100*stats_parse2['count']/stats_parse2.loc['cis', 'count']" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [], + "source": [ + "stats_all = pd.concat([stats_parse, stats_parse2, stats_mc3c])" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '++' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 187, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '--' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 188, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '+-' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABwgAAAPoCAYAAADKmKoXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3yN9///8eeJLBIRI/b82Ktq1N5F7VHUHqWKorWVllItimjVpvZepWLW3gkRm4pRe8UIkhiRnN8ffud8c3pOIiFxkMf9dju3Nu9xXa/rOte5jtv1Ou/32/Dw4UOjAAAAAAAAAAAAACQKDvYOAAAAAAAAAAAAAMCbQ4IQAAAAAAAAAAAASERIEAIAAAAAAAAAAACJCAlCAAAAAAAAAAAAIBEhQQgAAAAAAAAAAAAkIiQIAQAAAAAAAAAAgESEBCEAAAAAAAAAAACQiJAgBAAAAAAAAAAAABIREoQAAAAAAAAAAABAIkKCEAAAAAAAAAAAAEhESBACAAAAAAAAAAAAiQgJQgAAAAAAAAAAACARIUEIAAAAAAAAAAAAJCIkCAEAAAAAAAAAAIBEhAQhAAAAAAAAAAAAkIiQIAQAAAAAAAAAAAASERKEAAAAAAAAAAAAQCJCghAAAAAAAAAAAABIREgQAgAAAAAAAAAAAIkICUIAAAAAAAAAAAAgESFBCAAAAAAAAAAAACQiJAgBAAAAAAAAAACARIQEIQAAAAAAAAAAAJCIkCAEAAAAAAAAAAAAEhEShAAAAAAAAAAAAEAiQoIQAAAAAAAAAAAASERIEAIAAAAAAAAAAACJCAlCAAAAAAAAAAAAIBEhQQgAAJCARowYIQ8PjxhfmTJlUtmyZfXdd9/pypUr9g4Z77GAgADVr19fWbNmVebMmXXw4MF42/bu3bvN13RUrVq1Uq5cuZQrVy5dvXrVqt+UKVNUokQJpU2bVpUqVbKou3Xrljp37qw8efIoXbp0mjhxYrzFC7yq8PBw/fzzz/rggw/k5eWlNm3a2DuklzJ9Bv/7GcO7ZeHChfLw8FChQoUsyn///Xfze7xy5Uo7RRc3Xbp0kYeHh7p06WLvUBKMn5+f+X3p37//G99/QECAUqZMqYULF9qsv3fvnq5fv66IiIhYba9SpUrKmjWrgoODo23TuXNn5c+fX48ePXqVkAEAwBtGghAAAMDOHj16pBMnTmjChAkqXbq0/v77b3uH9E6oXbu2PDw8NGLECHuH8k64e/euPv30U+3YsUPBwcF6+PChnjx5kuD7vX//vm7fvq3bt29bPYRcsGCBBgwYoMDAQD158kR37961qG/fvr0WL16smzdv6vHjx3r48GGCx/s2eJ1r2/SjhNq1aydAZJCk0aNH65dfftHFixf19OlTq+v2bWT6DL4LsSLuQkJCzO/xm7iv29O79N3/7Nkz8/vypr+/nj9/rq+//lq5c+dWixYtLOq2bt2q8uXLK3v27MqXL59y5MihoUOH6tmzZ9Fub/Xq1Tp8+LB69uwpT0/PaNsNGjRIQUFBGjZsWHwdCgAASECO9g4AAAAgsTh8+LBV2bNnz3Tx4kUtW7ZMf/75px49eqR27drJ399fmTJlskOUeF/5+fnp3r17SpIkiaZMmaLixYsrc+bMdo1pw4YNkqQPPvhA3t7eypAhg7nuwYMH2rt3rySpR48eatOmjdKmTWuXOIGoNm7cKEmqUqWKhg0bxnUJ4K0zceJEHTt2TIsWLZKDw/+NDVi+fLk6deqkyMhIc1lwcLDGjRuno0ePasWKFUqSJInFtiIiIvTTTz8pffr0Lx3xmS1bNrVv315//PGHmjVrpo8++ih+DwwAAMQrEoQAAABvSM6cOW2W58+fX7Vq1VK5cuXUu3dvhYaGasaMGRo6dOibDRDvtfv370uSMmbMqObNm7+x/a5fvz7aOlNMtWrVUqlSpSzqok5h1qlTJ2XPnj0hwgPizHTdNm3aVB9++KF9g4mlxDL6NrEaNGiQBg0aZO8w8B8VKlSwy2cvNDRU48aNU+7cuVW3bl1z+d27d9WzZ09FRkaqS5cu6tGjhzw8PLRlyxb17dtXW7du1bx58/T5559bbG/BggUKDAzUuHHjlCxZspfu/5tvvtGMGTP0888/a/Xq1fF9eAAAIB4xxSgAAMBbomPHjkqXLp0kad++fXaOBu8rg8Fg7xCsvCymtzFmgOsSwNto8eLFCg4OtppadOPGjXr06JEaNmyo0aNHK0uWLEqRIoUaN26syZMnS5L+/PNPiz5PnjzRqFGjlCNHDrVr1y5W+8+SJYsqVKig7du3KzAwMH4OCgAAJAgShAAAAG8Jg8FgHiV1584dm21u3Lih7777Th999JEyZMigbNmyqVKlSho3bpzFiKuounTpIg8PD02aNEmS9Mcff6hYsWLy9PTU7t27LdoGBQVp8ODB+uijj5Q+fXplyJBB5cqV04gRI/TgwYNoYw8ODtaIESNUvnx5Zc6cWZkzZ1a5cuU0bNgw3bx502Yf01ppPXv2lCSdOnVKHTt2VL58+ZQ6dWrlzZtXXbp00b///mvRz7T+0J49eyRJo0aNkoeHhwoVKmS1j23btqlt27YqWLCgvLy8lCZNGuXPn18tW7bUpk2boj0eSbp06ZK++eYbFSpUSF5eXipQoIB69eqlGzdu6Pnz5/Lw8JCHh4fOnz9vs39AQIC+/PJL877z5s2runXraunSpQoPD49x3zF5/vy5Zs2apdq1ayt79uxKnTq18uTJo1atWpmnPoxq4cKF8vDwUNeuXSVJly9fNsf+3/f/ZdasWaNGjRope/bs8vLy0gcffKDevXvr+vXr0faxtSZeTO/hpUuX5OHhocKFC5vbFy5cONo1p17lPBcqVEgeHh46duyYwsLC9O233yp37tzy8PCwavu2XtvR7XPUqFGSpD179pjf50uXLmno0KHy8PBQzpw5LaaW+69atWrJw8NDDRs2NJeZthMcHKx79+5pyJAhKlq0qNKmTascOXKoQYMGWrVq1UtjXLVqlZo0aaKcOXOar5+2bduap5KNzpYtW9SyZUvlyZNHqVOnVsaMGVWxYkV5e3vr8ePHL91vdAIDA/X111+rSJEiSps2rfm9/fHHH22u1We6bi5fvixJ6tq1a5zWe/zvvXjJkiX65JNPlDVrVmXIkEGlS5fWTz/9FOO99vHjx5o4caJq1KihbNmyKVWqVMqQIYNKlSqlAQMG6MqVKzb7RbduW2y/H8LCwjR+/HhVrVpVmTNnVqpUqZQzZ041bdr0ldbNNX3Ovby8zMc1evRolSxZUunSpVOmTJlUq1YtrVmzJsbtHDx4UF988YUKFCggLy8vZc2aVVWqVNG4ceMUGhpqs09sjtl03zQlWHbt2mW+92XIkEFVq1a1uObPnz+vL774Qrlz51bq1KmVP39+9e3bN8b38nW+n/5r9+7d5s9pVKb7Qmxe0X0fvOrn9uHDhxoxYoTKlCmj9OnTK3PmzKpSpYqmT58e4z0oOnG5P167dk3ffvutSpQoYf63TIkSJdS/f/9oPyOxdfz4cXXu3FkFChRQmjRplDVrVtWqVUvz58+3eVwxnd8zZ86Y70FeXl5KmzatihYtqj59+ujq1auvHOO0adNkMBjUrFkzi/IbN25IksqWLWvVp1y5cpJenLuoZsyYoWvXrum7776Tk5NTrGNo0aKFjEajpk6dGtfwAQDAG8QUowAAAG8RU8IhefLkVnV///232rdvr5CQEHNZaGio7t+/r8OHD2vy5Mlavny5ihYtGu32+/Xrp2nTptms279/v5o1a2aVaDx+/LiOHz+uxYsXy8fHx2qqx4CAADVt2lRBQUE2+02bNk1z5sxRjRo1oo1ry5YtatOmjcUD3Rs3bmjRokVav369Nm3apPz580fb35ahQ4dq3LhxVuXXrl3TtWvXtHbtWvXr10+DBw+2arNt2za1bNlSYWFh5rKrV69q5syZWrNmjVasWBHjvkeOHKlRo0bJaDRaHM+NGze0a9cuTZ8+XcuWLVPq1KnjdEx3795V48aNFRAQYFF+8+ZN+fj4yMfHR82aNdOUKVPk6Bh//9R//vy5unbtqqVLl1qUX7x4UX/88YdWrFihb7/9Nt72F1uve54fP36sunXryt/f32b923ptv4oGDRpo3LhxCgoKkq+vr80HxDdu3ND+/fslSZ999plV/YULF9S6dWuLB9dPnjzR9u3btX37dvn4+Gj69OlW197jx4/Vrl07qwT2xYsXdfHiRa1evVqff/65xo0bZ7X2la17Vnh4uI4cOaIjR45o1apV2rBhg817Zkzmzp2rXr166fnz5xbHYnpvZ86cqWXLlllNfRsfjEajOnbsqOXLl1uUnzp1SqdOndLChQu1Zs0a5c6d26L+7t27qlOnjk6dOmVR/vz5c50+fVqnT5/WokWL5OPj80pTn0b3/XDjxg3Vq1fPaiRQUFCQNm3apE2bNum7777TgAED4rxP6cWUrQ0bNrRap3fv3r3au3evBg8erH79+ln1GzFihH755ReLz//Tp0916NAhHTp0SLNmzdKqVauszmNUMX0nmsyaNUu9e/e2SP74+/urXbt2unnzpooUKaImTZpYfDdfu3ZN06dP1+HDh7Vlyxar0aav8/30przO5/bs2bNq2LChVTLO9N5s2LBBqVKlSpC4N27cqPbt21t8f0svfhAQGBiouXPnaubMmRZTb8bWlClTNGjQIEVERJjLnj17Zr5WV65cqSVLlsjV1fWl21qxYoU6d+5s9UOW8+fP6/z581q+fLk2bNigggULxinG/fv368yZM/roo4+UJUsWizrTOr979+61WkvQdO9Pnz69uezhw4fy9vZWoUKF1KRJkzjFUb9+fXXv3l1Lly7VyJEj5eLiEqf+AADgzWAEIQAAwFti/fr1unTpkiSpePHiFnXHjx9Xy5YtFRISoty5c2vy5Mnav3+/du7cqWHDhsnT01O3b99WnTp1ov3V+fLlyzVt2jRVrVpVs2bN0p49e1SiRAlJ0pUrV9S0aVMFBwcrQ4YMGj9+vPbt26eNGzeqR48ecnJy0qVLl9SuXTuLh7HXr19Xo0aNFBQUpIwZM2r06NHas2eP9u7dK29vb2XMmFEhISFq3ry5Dh06ZDOuy5cvq0OHDsqUKZNmzJghX19f+fj4qHHjxpJejOD6/vvvze3/+OMPHT582HyOOnfurMOHD1usdefn52d++Fq0aFHz8e7cuVOTJ09Wrly5JEljx461GsX177//qlWrVgoLC1P69OnN52Lz5s366quvdO/ePbVs2TLa9/GPP/7QyJEjZTQaVbVqVS1dulQHDhzQxo0b9eWXX8rBwUEHDx5Uo0aN4jSKIjIyUq1bt1ZAQIAMBoNatWqltWvX6sCBA1qyZIkqVqwoSVq6dKl+/PFHc7/69evr8OHD5rKMGTPq8OHDOnz4sPn9f5nhw4ebk4NFihTRnDlz5Ovrq/Xr16tly5YKDg6O04PsmN7DTJkyWb2f69ev1+HDhy0eaMbHee7fv7+OHDmizz//XMuXLzc/IJXe3ms7Ol26dNHhw4fVuXNnSS/uIab3OVOmTCpatKiyZcsmSfLx8bG5jZUrVyoyMlJJkyZVvXr1rOrbt2+vq1evqnnz5lq/fr18fX01a9Ys82jPFStW2Bzl2bVrV23cuFEODg7q2LGj1q9fr4MHD2rZsmWqVq2aJGn27NlWa6j5+PiYkzfly5fX4sWL5evrq02bNunLL7+UJB07dkzjx49/6fmJavv27fr666/1/PlzZc2aVRMmTNC+ffu0Y8cODR48WO7u7rp//76aNm1qHnEj/d91mDFjRknSjz/+qMOHD+uPP/6I0/6nT5+u5cuXK2/evJo1a5b8/Py0bt06tWnTRgaDQdeuXVPTpk2tRkcOGzbMnBzs0KGDfHx85Ofnp40bN6pPnz5ycnLSgwcPXmktupi+H3r16qXAwEAlSZJE33zzjTZt2iRfX18tWrTI/IOUUaNG6dy5c3HeryR1795dp0+fVr9+/bR9+3bt2LFDP//8s3k03MiRI61GKc+dO9f844CCBQtq5syZ8vX11ebNm/XNN9/I2dlZly9fVuPGjS0Sd7E9ZpPjx4+rb9++qlKlitasWaM9e/Zo9OjR5tiGDBmiZs2ayd3dXZMmTZKvr6+WLFmifPnySXoxwnHHjh0W23yd76e4Mt0XbL38/f1VoEABSS++F/77Q4VX/dyGhoaqSZMmunLligwGg9q3b6/169fLz89Ps2bNUv78+bV169Y4r00Xm/vj6dOn1aZNG4WFhSl16tQaMWKEdu/ebX7fvLy89PjxY7Vv317Hjx+P0/7Xrl2rAQMGKCIiQiVKlNDChQvl6+urP//8U3Xq1JH04sdFUb9/o3Pjxg1169ZN4eHhyp49uyZNmqTdu3dr+/btGjFihNzd3RUcHKw+ffrEKUZTnJJUsmRJq7qaNWvKw8NDf/31l3k05cOHD7Vq1Sp99dVXkmSRCBw/frzu3bunwYMHy8Ehbo8PkydPrnz58unRo0fauXNnnI8DAAC8GYwgBAAAsKOnT5/q0qVLWrZsmSZMmCBJcnR0ND/8NunTp4+ePXum/Pnza9u2bXJzczPXFS1aVPXq1VONGjV0584dDRkyRLNmzbLaV0BAgDp06KDffvvNqm7IkCF6+PChUqdOrS1btlj86rxs2bLKmTOnevbsqcOHD2vfvn3mqaiGDBmi+/fvK23atNq5c6d5DUXpxbSQjRo1UvXq1XX+/HkNGDBAW7Zssdr3li1bVKhQIW3cuNFierRKlSopPDxca9assViT0fRwPmnSpJKklClTKmfOnBbbNI3wy5Ahg3x8fCy2W7RoUVWrVk358uVTZGSkDh8+rBw5cpjrhw4dqtDQUPO5yJo1q7muVKlSyp07t3r16mV1HNKLhM+QIUMkSa1atdKUKVMs6suWLatKlSqpdevWOnLkiObOnavPP//c5rb+a9WqVeYp3YYPH66vv/7aXJcvXz7VrFlTbdu21Zo1azRhwgR9+eWXypw5s5InT67kyZObp/JzdHS0Ol8xuXr1qn7//XdJL6YgW716tcVIgPLlyytbtmwaOXJkrLf5svcwZ86cFqPQsmTJYk5uSfF3ng8fPqxZs2bZHBnxtl7b0UmVKpVSpUqllClTmrfx377169fXhAkTtHbtWpvv18qVKyW9mMrP1oi8ixcvasCAAfruu+/MZQUKFFCdOnXUoEED+fr6avz48fryyy/No1C2b99uXtNq0qRJatWqlblv3rx5VbNmTX377beaPHmypk+frs8//9ycXDFN4ZgrVy6tXr1azs7O5r5lypTRpUuXtGnTJm3evNki0foy/fv3l9FoVPbs2bVt2zalSZPGXFesWDFVqVJFNWvWVHBwsEaOHGm+/k33AtO16eXlFafPksnFixdVoEAB/f333xbXRYUKFVSoUCENGDBAFy5c0IwZM8yfc6PRaD6PX375pcaOHWuxzbJly8rDw0M//PBDtAnrmET3/RAWFmae7rJ///4aOHCgua5AgQLme2JERIS2bt1qTm7F1tOnT7Vu3Tr99ddfqlSpkrm8WLFiypUrl5o1a6bnz5/rwIED5mlvHz9+bP78Fy9eXOvWrVOyZMnMfUuVKqVSpUqpZcuWunjxoqZOnaq+ffvG+pijunz5sqpWraqVK1eaEyQffPCBkidPrq5du+rp06dycHDQ9u3bzcdeoEABFShQQMWLF1d4eLiOHz+uKlWqmLf5Ot9PcWW6L9jSt29fnTp1Si4uLpo/f77F5+B1PrdTp041Jza9vb31xRdfmPvmz59fn3zyiT755BOdOHEiTscSm/vjd999p6dPn8rT01ObN2+2uB4/+OADffLJJ6pcubLu37+v77//Xn/99Ves9v38+XPzKNYyZcrIx8fHfD8qUKCAqlWrps8//1wrV67U7Nmz9f3331tck/+1ceNGPX78WAaDQWvWrLGYmaF48eKKjIzU999/r/379+vRo0dxGiFtSsbZ+gFQ6tSp9euvv6pTp06aOnWq1fSf1atXN68zGBQUpClTpqh06dKqVatWrPcfVYkSJXTy5Ent3LkzxpH2AADAfhhBCAAA8IbYWvPHy8tLJUqU0OjRo/X48WM5ODho3Lhx5gdt0otfxPv6+kqSfv/9d4vkoEmuXLnMD27XrFljNbWWJDk7O+uHH36wKr9//755nac+ffpYTUklvRg5ZHp4aEpS3b9/3/wAf8SIERYJFJM0adKY10Q7cOCALly4YPPcRB2REZVppFV0a0lFJ0eOHGrZsqUGDBhgc7vp06c3P2yMOkrn3r175l/f9+3b1yI5aNKxY0eL9fGiWrZsmUJCQuTp6akxY8bYbFOvXj3zg+4lS5bE+pgWLlwo6cXDyB49eljVOzg4yNvbW05OToqIiLCaDvRVLVmyRBERETIYDJo4caLNacL69+//SomSVxVf57lYsWI2k4Nv87X9OurXry/pxfpvx44ds6i7ePGiObFka3pR6cXnytY0kkmTJtXEiRNlMBgUHh5uMXXm7NmzJUlVqlSxSDJENXz4cGXIkEEREREWfR89emTeb9TkoMmgQYM0ZcoU9e7dO9pj/q+DBw/qzJkzkl6MAIyaFDEpUaKEOaG8fPny11ozNDpjxoyxeV107drVPPJn0aJF5vKwsDDVrVtXLVu2VMeOHW1us1ixYpL0SusyRvf98PjxY/N0innz5rWq9/Ly0syZMzVlyhSb09bGRosWLSySgyY1a9Y0f99F/ZysX79e9+/fl/QiAWUrEVO3bl1zUiPqeYwqumP+r5EjR1qNnqpZs6b5/zt16mSVGM2ePbu57L+f8Vf9fopP8+fP1/Tp0yW9OIcfffSRRf3rfG4XLFgg6UXSOmpy0CR58uTR3rdfx82bN7V161ZJL76/bSWrc+TIYU707dixI8b1c6PavHmzeW2+0aNH27wfmZLQoaGhOnr0aIzbM93bkiVLZvPfGU2aNNGUKVM0efLkOI3cCwsL08mTJyUp2unmmzZtqj///FNFihQxl3l6eqpv375asmSJebrYX375RSEhIRo6dGis9/9fpnvSgQMHXnkbAAAgYZEgBAAAeAs4OjqqYsWKWrdundq3b29Rt2fPHklSihQprB7iRWWaYvLZs2c6ffq0VX2RIkXMo4uiOnDggPkBuCmB8F8ODg7asmWL9uzZo9atW1v0MxgM+vjjj18alySbD81Sp06t8uXL2+xr6+F9bHz11VeaOnWqOnToYLP+3Llz5vUeo4p6Lho0aBDt9qOrMyVPy5QpI3d392j7V6hQQZKskjTRMRqNOnjwoCSpYcOGVutZmaRLl848ujO+Hsj5+flJejFdWXRJwCRJkpgTXm9CfJ3nypUr2yx/m6/t11GyZElz4sH0owAT0+jB1KlTm6cP/K/GjRtHu7Zlnjx5zFP/ma4Z6f/uX9WrV482LicnJ5UpU0aS5Xk0/VBi27ZtmjFjhlWirmjRomrVqlWMn9X/MsXm4uKi2rVrR9vu008/lfTiYb/pgXt8yZQpk/natKVFixaSXvw45MGDB5IkNzc384if6NasjDoaNa6i+35InTq1efTxiBEjrNY/lV5cF61atYr2hxMvE933jsFgsLl+qOkHM9mzZzcnIGxp1KiRpBf3+7t371rVR3fMUXl4eNg831HjsjWVY9Q2Uaflll79+ym++Pn5mUfBd+zYUW3btrVq86qf2zt37uj8+fOSpObNm0fbt1y5cjZ/jPQ6Dhw4YD7XpvfeFlOd0WiMdv3Z/zJ9trJly2aRWIuqYMGC2rt3r/bs2WOeujU6pmR7aGioevbsaU54m2TMmFGtWrVSq1atbP4oLDrnz583J/Rt/bDFpGrVqtq9e7cuXryo06dP699//9WQIUPk5OQk6cWPSEzr675q4j9qDP9dvxQAALw9mGIUAADgDTl8+LDNcmdnZ3l5ecnV1dVmvWlk0oMHD+Tp6Rmrfdl6uBjdwzjT9t3c3Gz+kt3kf//7n81+RqMx1lOgRV3Py+R1pk+LjStXruj48eO6cOGC/v33X505c0a+vr56/vy5VVvTMbm7uytz5szRbjO6B/Sm/hs2bLA5MuS/QkND9eDBA6VIkSLGdg8ePDAnCqLbt0nevHm1Y8cOXbly5aX7jw3TqImXPfx/1eTAq4iv8xzde/yuXNtxZTAYVK9ePU2bNk1r1661mJbTlCBs1KiR+SHxf0X3YNzkgw8+kL+/vy5fvixJevjwoe7cuSPpxWi/2KyNF/Xe1b17dy1YsEB3795Vnz59NHz4cFWpUkVlypRR2bJlVbhw4WiT5dExfS5y5sxpcxSQSdTRcleuXNGHH34Yp/3EJLafJaPRqKtXr1pdtxERETp27JjOnDmjixcv6sKFCzp8+LB5ZOSriClZ88MPP6h79+4KDAxU5cqVlSdPHlWuXFllypRR+fLlY0xExEZcRx+b1tmNOtLelqj1V69etUo2xiZBFZvv3JclGWMSl++n+HD9+nW1bt1az549U+nSpTV69GirNq/zuTV9X0gvv84LFiwYb99T0v99tt3d3WN8bzNlyiQPDw89fPjQfK96GdN3gq1RtFHF9nuwevXqKleunPbu3as5c+Zo0aJFKleunMqVK6cyZcqoZMmSNkfrv4zps+Hs7ByrxGJ008/+/PPPCg8PN0/lK72470yePFnz5s3Tv//+qzRp0qhOnToaNGiQzUS+9H+fjfv37ys0NDROyU4AAPBmkCAEAAB4Q151CsaQkJA497E1bWF0CUjT9mMaiRVfcdma+jS6uF7XggUL9Pvvv+uff/6xKHd0dFTRokV1+vRpq2Mw/f2yh1jRnSvTtGFxERYW9tIEYdT382WxmdYqepVYYtr3yxJxsUnUxZf4Os+mtaz+622/tl9HgwYNNG3aNJ06dUrnz59Xzpw5FRgYaF4PrFmzZtH2fdl1aqp/+PChpNe/d6VLl047duzQiBEjtHr1agUHB2vVqlXm6V/Tpk2rVq1aqVevXrH+8YRp+y/7HEW9nk3HE19edh6jHkvUa/3u3bsaMWKEli9fruDgYKs+H330kXmkcVzFdK22bdtWadKk0ZgxY3To0CEFBgYqMDDQPEVlsWLF1L17d5vT9cZGXBMhsX0Po67bZuueYc/P56t8P72uJ0+eqGXLlrp165YyZsyo+fPn2/wxwOt8bqPeB9/0d0ZsrwvpxXf4w4cPY/1dYjoncVkLMCYODg5asWKFxo0bpzlz5igoKEjbt2/X9u3bJb2YerRu3boaMGCAcufOHevtmo4ntvdDW06dOqVly5bp008/1QcffCDpRXKwdevWWrdunaQXo0evX7+uGTNmaPPmzdq8ebPNHwpETZ4/evSIBCEAAG8hEoQAAABvOVMSo2DBgua1fV4mbdq0cd5+XNc6MvVLmTKltm3bFqs+0f1aPb4NHjxY48ePl/RiVFONGjVUsGBB5c6dW3nz5pWLi4sKFSpk9SDUtJaVrWRPVNGdK1P/du3aqWfPnrGK1TR9X0yirrH1sjXrTLHbWpfrVZgeiL4sSfIm19JLqPNs8jZf26+rbNmySps2rW7fvq21a9fqm2++Ma8flj17dpUqVSravi+7R5geTpseAkdNwE6YMCHa6Vaj+m/CIlu2bJo2bZrGjRunvXv3ml8BAQG6ffu2fv31V23YsEE7d+6MNuEblenaedn1GpekfFzF9jxK/xfv/fv3VaNGDZ09e1bOzs6qW7euypYtq7x58ypPnjzKli2bdu/erTp16sRrrCa1a9dW7dq1dfnyZe3atcv8Ply8eFEBAQHq0KGDzp49a14LNyHF9j2Meh+Pr/thfHjV76fX9fXXXysgIEAuLi6aP39+tCM/X+dzG/XHM2/6OyO214X0f9dGbD/bpmRyfK4J6ebmpsGDB2vQoEHy9/fXnj17tG/fPvn6+urRo0datmyZ1q1bp+3bt790tKzJf6ezfRXDhg2Tg4ODxQjzadOmad26dcqRI4emTZumkiVL6sqVK+rdu7c2b96sXr162VzrM+r6ifERGwAAiH8kCAEAAN5ymTJlkvRi9MirjkKMzfYfPnyo27dvR5tcPHnypC5fvqw0adLoo48+suiXIUOGt+YB7OXLlzVx4kRJUv/+/S0eckUVGRlpVWaacvLRo0e6fv26eb22/4puPZ2MGTPqxIkTCg0Njdf3ytPT0zwl2j///BPjmmum9Sejiz2usmXLpmPHjplHmEUnvtdpi0lCnWeTt/Xajg8ODg6qW7euZs2aJR8fH33zzTf6888/JUlNmzaNse8///yjWrVqRVtvugZM156np6fc3d0VEhKiyMjI13qv3NzcVKNGDdWoUUOSdO/ePU2aNEljxozRP//8owULFqhTp04v3Y5p6sELFy7o2bNn0U4zGnVkV3x9lmxt25aonyXTvmfMmKGzZ8/K3d1dmzZtsjmVoa17WnzLmjWrWrdubV6L9tixY+rTp4/8/Pw0ZswYdevWLcFHE5vu0y87j1HX4jV9pu3tdb6fXseECRO0ZMkSSZK3t3eM6xm/zuc2a9asMhgMMhqNOnHihHldUlvi+zvD9NkOCQnR1atXo51C+ubNm+YRuLH9bJuun3PnzsXYbvfu3QoJCVGePHlifd6SJEmiUqVKqVSpUurTp4+ePn2q1atXq1evXgoJCdHIkSM1d+7cWG3L9Nn775qGseXn56cNGzaoQ4cOFvHPmzfP/F/TVNPZsmXTvHnzVKxYMa1fv1537961mmr03r175v+Pr9GXAAAgfjm8vAkAAADsqXTp0pJePNSKbh1DSVq9erXq16+vzz77LE4PF0uVKmVex2vt2rXRtuvWrZuaNWumOXPmWPSLiIjQ5s2bo+23f/9+1a9fXw0aNLB4WJRQjhw5ooiICElS165dbba5f/++bt26ZVUe9Vz4+PhEu4/o6kzv1fbt2/XkyZNo+w8fPlz169fX0KFDo20TlcFgUIkSJSRJf/31V7S/xL99+7b27t0rSTGOBIsL0zEdOHBA58+ft9kmMjLSnGR6ExLqPJu8rdd2fKlfv74k6eDBg9q4caPOnj0rKebpRaUX95joXLhwQX5+fpL+79ozGAzmRMSGDRui7fv8+XO1bt1a9evX14oVKyRJT58+VdWqVVW1alWb+02VKpUGDx5sXpMzajIoJiVLlpT0YrrFjRs3RtvOtCajq6vrS9dejKvAwECdOnUq2npTIidnzpxKkyaNJOnQoUOSpHLlykW7ztnrrEEYnTVr1qhq1aqqVq2azZFZH3zwgX755RdJL95H07WUkEzX18WLF3XkyJFo25nuSdmzZ3/tdRLjy+t8P72qbdu2mdeS69ixo9q2bRtj+9f53KZIkcL8mVy8eHG0ff39/XXx4sW4HMZLlSxZ0vz9HdO9yhSrqU9smL5zTNPr2vLgwQM1bNhQzZo104EDB2LcXrdu3VS1alUNGzbMqs7FxUXNmjVTixYtJMX+3ib9X/I8PDz8lUagDh06VEmTJtWAAQMsys+dO6eUKVNa3Qvd3NxUokQJRUZGmtdpjMqUqDQlnQEAwNuHBCEAAMBbrmTJkuY1aPr06WPzIe3t27f1/fffa8eOHUqaNKnFtE4vkzFjRlWuXFmS9Msvv+jmzZtWbbZv325OTn788cdW/QYPHqygoCCrfiEhIfr222+1Y8cOPXjwIEGmYYxp2qpr165ZlYWHh6tXr14KDw+36p8hQwbz8Y0ZM0bXr1+36r948eJo1/lq1qyZkiRJort370Y7MmT//v0aN26cduzYEadRLS1btpQknThxQpMnT7aqj4yMVK9evfTs2TM5ODioefPmsd52TJo2bSonJydFRkaqe/fuNhNyv//+e5weYr6uhDzP0rtxbb9O34oVKyplypQyGo3q1auXJOnDDz9Unjx5Ytzm4cOH9ccff1iVP336VN27d1dkZKSSJElikWhs1aqVJGnTpk3mtQP/6/fff9eaNWu0c+dOFShQQNKLh+Tnz5+Xv7+/Zs6cafN47t27p6tXr0qK/RSvJUuWVK5cuSS9eG/v3r1r1ebgwYOaNWuWJKlJkyZxXiMvNnr37q2nT59alc+cOVN79uyR9H/nLqobN27Y3N7Zs2c1evRo89/xNZ2fk5OT/P39deDAAf3111822xw9etT8/29iqt06deqY11jr06ePzWkffXx8tH79ekn/d+9828T1++lVnD9/Xu3bt1dERIRKly5tcY3E5FU/t9L/ne99+/ZpxowZVv3CwsLUp0+fuB6Klf+emwwZMpjv22PGjLGZsLpw4YLGjBkj6cV9MGvWrLHaV926dc3XXL9+/fT8+XOrNr///rvCw8Pl4OCgKlWqxLi9Bw8eyN/fX7Nnz7Y52i8yMtI8aj8un6mcOXMqSZIkkmTz33Ix+fvvv7V371517txZGTJksKhzd3fXgwcPbN4vL126JMn2NL6mRHdc1lEEAABvFglCAACAt5zBYNCoUaNkMBjk7++vihUrav78+Tpx4oQCAgL0xx9/6OOPP9bly5fl5uYWbcIkJj///LNcXFx048YNValSRbNmzdKJEyd04MABeXt7q02bNjIajcqXL5959FHUfhcvXlSFChU0ZcoUHT16VMeOHdOiRYtUvXp1HT58WA4ODvrpp5/i87SYk6CHDx/Wo0ePzOt2lSxZUo6OL2bS79Chg1auXKmTJ0/K19dX06ZNU4kSJfTnn3+a+69du1anTp0yJ75Mx3T79m19/PHHmjNnjk6ePCl/f38NGTJE3bt3N4+QkGR+GCe9mOLsm2++kSRNnz5dDRs21Lp16/TPP//I19dXP/30kxo3bqyIiAjlz59fbdq0ifXxNm7c2DzaYdCgQerWrZt2796tf/75R+vXr1fdunXNIxt79Oih7Nmzv8pptZI+fXrzOn979+5VtWrVtGLFCp0+fVr79u1Tjx499MMPP7zRKfwS8jybvI3Xdlz6nj9/Xjdu3FBoaKh5xJKJo6Ojea06U5Lis88+i9W2+/btq169emn//v06ffq0Vq5cqWrVqpmTWj169DBP9Se9uG5Lly4to9Gozz//XL169dKuXbv0zz//aNu2bercubN5hGebNm0sEg316tWTJO3cuVNt2rTRpk2bdOrUKQUEBGjOnDmqVq2aHj16JEdHRzVp0iRW58dgMGjkyJGSpH///VdVqlTRvHnzdPLkSQUEBOiXX35RgwYN9OzZM3l6euq7776L1XbjwsHBQfv27dMnn3yiv/76S//884/27Nmjr7/+Wr1795b0YtRbly5dzH3KlSsn6cWUnp06ddKePXt0+vRp/f333+rbt6/KlSunO3fumNvPnTs3XkZolS9f3iIZN3r0aPn6+ppjHjJkiPr16yfpxci+HDlyvPY+XyZZsmQaPHiwpBfJ3Kj3JD8/P33//fdq3769pBfnsVu3bgkeU2y97vdTXDx58kQtWrRQcHCwPDw8NGzYMF2+fFnnz5+3+Yr6Q4jX+dx26tTJPD1l37591b17d+3evVunT5/WqlWrzPfO6KYAfZmY7o/Dhw+Xs7Oz7t+/r2rVqmny5Mk6duyYjh07pilTpqhatWq6f/++nJ2d9fPPP8d6n8mSJTMf7/bt21WzZk35+Pjon3/+0a5du9SzZ095e3tLerE2bvr06WPcXt26dSW9+JFD/fr1tWzZMh05ckQnTpzQmjVr1KhRI+3fv1+S4vRjn2TJkqlgwYLm8xNbRqNRP/74o1KkSGH+0UhUVapUUWRkpL7++muLhPyvv/6qY8eOKX369Bb/LjIxxRDTlLYAAMC+WIMQAADgHVC9enWNHz9evXv31tmzZ20+8PT09NTcuXNf6ZfahQoV0ty5c/X555/r2rVr5oRQVFmyZNGiRYvMDzdN/ebNm6cOHTro+vXrVtNSSS+m6Pv9999Vvnz5OMcVk7x582rXrl36+++/lSlTJmXNmlUnTpxQ+vTpNWDAAP38888KDAzU559/btHPYDCoX79+CgsL06RJk7R+/XqtX79ee/bs0QcffKD8+fNr5syZ6tChg65du6avv/7aon+hQoW0dOlS80O4//5q/vvvv1dQUJDmz5+vbdu2adu2bVax58+fXytWrJCrq2usjzdJkiRauHChGjdurGPHjmn+/PmaP3++VbvmzZvrhx9+iPV2Y2PQoEG6cuWKlixZomPHjqlDhw4W9WnSpNHy5ctVtmzZeN1vTBLqPJu8jdd2bOTLl0/Si9EjefPmlSQdP35c2bJls2hXv359LViwQNKLB+6xSbD9/PPPGjdunGbOnKmZM2da1X/66afmxI2J6bpt0qSJDh8+HG3fhg0bmh+wmwwePFh79uzRhQsXtGbNGq1Zs8aqn7Ozs8aPH28+7tj45JNP5O3trf79++vixYvq3r27VZtUqVJp6dKlCZL4btSokcLCwrRhwwabyeuMGTNq+fLlFlPydezYUYsXL9bJkye1dOlSLV261KKPl5eX5s2bp/bt2+vWrVv6+uuvVbhwYfOUw68qefLk+vXXX9WpUyeFhoZGmwzPlSuXzdGlCaVTp066du2axo0bp+PHj1vdk6QXa6StXLnyrVr77HW/n+Li1q1b5nUaHz58qE8++STG9i1bttTUqVMlvd7nNmnSpFq+fLkaNGigK1euaN68eeY17Ew++eQT1alTx+r7NTZiuj9+8MEHmjNnjjp27Kg7d+7o22+/teqfNGlSzZw5M85TB3fo0EFXr17V2LFjdeDAAZsjfCtVqqRRo0a9dFtNmzbVX3/9pXXr1uno0aP64osvot1nu3bt4hRnpUqVdOzYMfn7+790XVmTFStW6NixYxoyZIhSpkxpVT9o0CBt2rRJPj4++vDDD1WsWDFduHDBPHPA8OHDbc5cYZoauVKlSnE6BgAA8OYwghAAAOAd0b59e/n5+alDhw7KkSOHXF1dlTRpUuXPn189e/bUwYMHXzqtVUxq166tgwcPqlOnTvrf//4nV1dXJUuWTIULF9a3336rvXv3mqfmi6pWrVo6dOiQunfvrnz58snNzU0uLi7KmTOnvvjiC+3fvz/epruMatCgQapXr55SpEghZ2dnZcyY0Vw3YMAAzZ8/XxUqVFCKFCnk5OSkzJkzq0WLFtq5c6cGDx6s77//Xo0aNVKyZMmUNWtWi4fx9evX1969e/XZZ58pXbp05uMZOHCgtm3bZpEUdHNzs4jL0dFRkyZN0qpVq9SgQQNlyJBBTk5O8vDwUKlSpTRq1Cjt2rXLYpRVbKVLl07bt2/XuHHjVK5cOaVMmVJOTk5Kly6d6tSpo2XLlmn69OkWSdz4kCRJEk2fPl2LFi1StWrVlDp1ajk7Oytr1qz64osvtG/fPhUqVChe9/kyCXmeTd7Ga/tlGjRooG+++Ubp0qWTo6Oj0qdPL2dnZ6t2VatWlYeHh6QXD29fNuJFevHw/cCBA+rRo4f+97//ycXFRSlTplSVKlU0Z84czZkzR05OTlb9vLy8tHXrVv3++++qWLGiUqVKJUdHR6VJk0affPKJFi1apHnz5llN5ZkuXTrt2bNHQ4cOVcmSJeXp6akkSZLIzc1NBQoUUJcuXeTn52fzQf3LdOrUSfv27VPbtm2VPXt2ubq6yt3dXYUKFVLfvn116NCheFvH879cXFy0ZMkSTZ06VWXKlJGHh4f5Xt6vXz/5+fmZk7smbm5u5tGCefLkkYuLi9zd3fXBBx9o0KBBCggIULly5bRgwQLly5dPrq6u8TatX+PGjbVr1y61a9dOuXLlUtKkSeXo6KjUqVOrYsWKGjNmjPbt22eVhE5oQ4cO1ebNm9W0aVNlzpxZzs7OSpEihYoVK6ahQ4fK19f3rZza8HW/n96UV/3cSi8Sxr6+vho0aJAKFSokNzc3ubu7q2jRoho3bpyWLl1q814RGy+7P9atW1f+/v7q0qWLcufOrWTJkilZsmTKnTu3unTpIn9/f/MIvrgaMmSI/v77b3366afm7xxPT0+VK1dOEydO1OrVq5U0adKXbidJkiRatGiRpk+frmrVqilt2rRydHSUi4uLsmfPrqZNm2rdunX67bffzOsqxpZpdPjL1kE0ef78uX7++WelTZs22nUxc+fOrRUrVih9+vS6ceOG1q1bp9OnT8vV1VVjxoyxuX5taGioTp06pWTJkpmnfgUAAG8fw8OHD+NncQIAAAAgkThw4ICqVaumNGnS2FznCHjb3bt3T3ny5NGzZ880ZcqUGJNspkTiunXrVKFChTcV4nunS5cuWrRokcVILQCIT0ajUR999JHOnj2r48ePv3SdxQsXLmjJkiUqVaqUeQ3m6ISGhmrTpk36999/lTp1an3yySdW6xWaLFmyRF9++aU+//xzjR8//pWPBwAAJCymGAUAAACiaNeunZ49e6aOHTuqWrVqNtts3LhRkizWXQLeJStWrNCzZ8+UNGlSi3VFAQDvLoPBoM6dO6tPnz5asmSJ+vfvH2P7//3vfxo0aFCstu3m5qZPP/00Vm0XL14sSRZrqQIAgLcPU4wCAAAAUVy6dEnr1q3T2LFjFRERYVV/9uxZTZs2TZJUo0aNNx0eEC/mzp0r6cU0qm/TGm0AgNfTsmVLpUiRQkuWLLHL/q9fv66dO3eqSpUqyp8/v11iAAAAsUOCEAAAAIjC9Gv3ffv2qWHDhlq3bp1OnTqlgIAAjR8/XtWrV9ejR4/k6en5SmufAfby999/a/369erWrZuOHz8uSercubOdowIAxCc3Nzf17t1b586dk4+Pzxvf//jx42U0GmM9MhEAANgPU4wCAAAAUTRv3lz+/v6aPn26du7cqZ07d1q1SZo0qWbOnKnUqVPbIULg1fz222/as2eP+e/GjRurTJkydowIAJAQevTooRUrVmj48OGqU6eOHBzezPiAK1euaNasWfriiy9UqlSpN7JPAADw6hhBCAAAAPzH2LFjtXLlStWpU0fp0qWTo6OjPDw8VKBAAX311Vfy9/dX9erV7R0mECf58uVT0qRJlSlTJvXq1UtTp061d0gAgATg6Oio33//XWfPnjWvB/gm/Pzzz0qTJo2GDh36xvYJAABeneHhw4dGewcBAAAAAAAAAAAA4M1gBCEAAAAAAAAAAACQiJAgBAAAAAAAAAAAABIREoQAAAAAAAAAAABAIkKCEAAAAAAAAAAAAEhESBACAAAAAAAAAAAAiQgJQgAAAAAAAAAAACARcbR3AHj3/PLLL/L09FSyZMnsHQqAV3Dv3j0tXLjQ3mEAAAAAAAAAAP6/q1evKlmyZDp37twb2R8JQsSZp6enqlSpIgcHBqAC7xqj0ShfX18+vwAAAAAAAADwFgkPD1dYWNgb2x8JQsRZsmTJ5ODgoKJFi9o7FABxdOHCBdWsWVNfffWVvUMBAAAAAAAAAPx/BQsWVGRk5BvbH0NIAAAAAAAAAAAAgESEBCEAAAAAAAAAAACQiJAgBAAAAAAAAAAAABIREoQAAAAAAAAAAABAIkKCEAAAAAAAAAAAAEhESBACAAAAAAAAAAAAiQgJQgAAAAAAAAAAACARIUEIAAAAAAAAAAAAJCKO9g4Ab7egoCDduXPHoiwiIsJO0QAAAAAAAAAAAOB1MYIQMZoxY4ZKlSpl8QoNDZXRaLR3aAAAAAAAAAAAAHgFjCBEjDp16qRGjRpZlPn5+clgMNgpIrytTNfEv//+q+zZs9s3GAAAAAAAAAAAEC0ShIiRl5eXvLy8LMr8/f3tFA0AAAAAAAAAAABeF1OMAgAAAAAAAAAAAIkICUIAAAAAAAAAAAAgESFBCAAAAAAAAAAAACQiJAiBt9iOHTtkMBhUt25dSdK0adNUuHBhJU2aVJkzZ1bfvn315MkTSdKJEyfUsGFDpU6dWsmTJ1fx4sW1aNEim9s9deqU2rVrp6xZs8rFxUWpU6dWtWrVtHDhQhmNRpt9IiMjNW3aNJUqVUrJkydXihQpVL58eS1duvSlx3H69Gm1b99eWbNmlaurq3LkyKHmzZvr8OHDr3hmAAAAAAAAAADAq3K0dwAAYuebb77R77//bv772rVr8vb21j///KP+/furZs2aevz4sbk+ICBArVq1kiS1bNnSXL5s2TK1bt1a4eHh5rJ79+5p69at2rp1q1avXq1FixbJycnJXP/s2TM1adJEPj4+FjHt3btXe/fu1YkTJ6KN29b+Ll68qIsXL2rZsmWaPHmyunTp8gpnBAAAAAAAAAAAvApGEALvgL1792rKlCmaOHGiHj58qMuXL6t58+aSpHXr1qlGjRoqVKiQ/P39FRYWpp07dypr1qySJG9vb/N2Tp8+rbZt2yo8PFyVK1fWgQMH9OTJE125ckVDhw6Vg4ODVqxYoREjRljsf9iwYebkYL9+/XTx4kU9fvxYe/fuVbFixfTTTz/ZjPvYsWNq06aNwsPDVb9+fR09elRPnz7V+fPn1a1bNxmNRnXt2lWbN29OiNMGAAAAAAAAAABsMDx8+ND2fIJANObPn68yZcqoaNGi9g7lvbdjxw5VqVJFkvTzzz9r0KBB5rqwsDBlypRJwcHBSpUqlQIDA5U6dWpz/aJFi9SqVSu5ubkpJCREktSmTRstWLBARYsW1f79++Xi4mKxv9GjR2vAgAFyd3fX9evXlTx5cgUHBytTpkwKCwvT999/r+HDh1v0uX//vvLmzaugoCBJ0r///qvs2bNLkurXry8fHx9VqlRJ27dvl8FgsOj77bff6pdfflGxYsV06NCh+DlpiNGFCxckSf/73//sHAmA2EjXY2ac2t+a0DGBIgEAAAAAAEBCKliwoCIjI3XgwIE3sj9GEALvAIPBoB49eliUJUuWTHnz5pUktW/f3iI5KEnFihWTJIWGhkp6sYbgX3/9JUn6/vvvrZKDktSzZ0+lSpVKISEh5lF9mzZtUlhYmFKkSGGRoDRJmTKlvvnmG6vyhw8fav369ZKkMWPGWCUHJWnIkCFyc3NTQECALl++HPNJAAAAAAAAAAAA8YIEIfAOyJAhg5InT25V7urqKknKly9ftHUmFy5c0KNHjyRJH3/8sc39ODs7q0KFCpKkI0eOWPy3UqVKSpo0qc1+derUsSo7fPiwIiIi5ObmZk5W/leyZMlUqFAhSdKpU6dstgEAAAAAAAAAAPHL0d4BAHg5Jyen16qXpDt37kiS3N3dlSJFimjbZc6c2aL93bt3Jcm8pqEt2bJlsyq7deuWpBcjGB0dX36ruX379kvbAAAAAAAAAACA18cIQiCRMBpfLDdqa6rPqEz1kZGRkqQkSZK8tJ+pTVQRERFxii8sLCxO7QEAAAAAAAAAwKthBCGQSKRJk0aS9OjRIz148CDaUYTXrl2TJPOahmnTppUkXbp0KdptX7x40arM1L9gwYI6ceLEK8cNAAAAAAAAAADiFyMIgUQiZ86c5nUMt2/fbrNNeHi4du/eLUkqUqSIJKlo0aKSpJ07d+rx48c2+23evNmq7MMPP5QknTt3LsbRgUeOHJG/v7+ePXsWuwMBAAAAAAAAAACvhRGEQCLh4OCgevXqadGiRfrpp59Uu3ZtOTs7W7QZN26c7ty5Izc3N33yySeSpOrVqyt58uR68OCBRowYoeHDh1v0efTokcaNG2e1v7Rp06pcuXLau3evvL29NXjwYKs2mzdvVo0aNZQqVSrzmoUAgFe3uUPmWLetPutqAkYCAAAAAACAtxkjCIFEZNCgQXJxcdGhQ4dUq1Yt88i9a9eu6YcfftCgQYMkSb179zZPQerm5qY+ffpIkn766Sf169dPly9f1tOnT+Xn56fq1avr+vXrcnd3t9rfjz/+KIPBoB9++EEdOnTQkSNHFBYWpps3b2ratGlq3LixJKlPnz5ydOT3CgAAAAAAAAAAvAk8kQcSkYIFC2r27Nlq27attm3bpo8++siqzaeffmo12m/QoEEKCAjQmjVrNHbsWI0dO9aifvDgwdq2bZv27t1rUV61alV5e3urT58+mj17tmbPnm21v2bNmmnAgAHxcHQAAAAAYF9eY7rFqX1Qv0kJFAkAAAAQM0YQAolMixYtdPjwYbVt21ZZsmSRs7OzPD09VaVKFS1YsEArVqyQk5OTRR8nJyetWrVK06dPV+nSpeXu7i53d3eVLl1aS5Ys0Y8//hjt/nr16qV9+/apadOmSp8+vRwdHZUqVSpVr15dy5Yt05IlS5QkSZKEPmwAAAAAAAAAAPD/MYIQMQoKCtKdO3csyiIiIuwUTeJTuXJlGY3GaOt37NgRbV327Nmj7VuoUCHNnTs3TrE4ODioU6dO6tSpk836PXv2RNu3dOnSWrZsWZz2BwAAAABIOIx2BAAASNwYQYgYzZgxQ6VKlbJ4hYaGxpi0AgAAAAAAAAAAwNuLEYSIUadOndSoUSOLMj8/PxkMBjtFBAAAAAAAAAAAgNdBghAx8vLykpeXl0WZv7+/naIBAAAAAAAAAADA6yJBCAAAAAAA3lqslQeuAQAAgPjHGoQAAAAAAAAAAABAIkKCEAAAAAAAAAAAAEhESBACAAAAAAAAAAAAiQhrEAIAAAAAgEQjXY+ZcWq/IPSH2DfO3yCO0QAAAAD2QYIQAAAAAADgLUQyEwAAAAmFKUYBAAAAAAAAAACARIQRhAAAAAAAJEJeY7rFum1Qv0kvbROX0W63JnSMdVsAAAAA8Y8EIQAAAAAAeKM2d8gc+8ZMhQkAAADEOxKEAAAAAAAAQDyIy8hcKXajcwEAABICaxACAAAAAAAAAAAAiQgjCAEAAAAAAPBGMc0sAACAfZEgBAAAAADgLZWux8xYt10Q+kPcNk7SBfEoLteqJC1IoDgAAAAQO0wxCgAAAAAAAAAAACQiJAgBAAAAAAAAAACARIQpRoF32KpVqzRw4EBJ0rx581SyZEk7RwQAAAC8X+K0Tpqk6rOuJlAkAAAkXl5jusW6bVC/SQkYCQC8P0gQ4o2I61oEb6tbEzraOwQLDx480JkzZyRJYWFhdo4GAAAAeDfEaV2/OG6bB5gAAAAA3gUkCAEAAAAkKnFJDr1tPxADAAAAACA+kCAE3mHt27dX+/bt7R0GAADAe+tdml7yXYoVAAAAAGBfJAgBAAAAvDZG5SWMhJwKM77FKdbQH+K0bZKZAAAAABC/HOwdAJCY7Ny5U02aNFHmzJnl7OysZMmSKW/evOrevbuuXLli1X7OnDkyGAzq3r27IiMjNXToUGXMmFE5cuSQJF28eFEGg0EGg8Gi39ChQ2UwGDR27FiFhYWpX79+ypYtm5ImTaoCBQpo+vTp5rarV69WuXLllDx5cnl5eal69eo6ePCgzfifPXum8ePHq2zZsvL09JSjo6NSpkyp8uXLa/LkyXr+/Hm8nCfTcRUqVEiStHbtWlWuXFkpUqSQh4eHypQpo1mzZsloNNrsf/v2bfXr10+FChWSu7u7nJyclCFDBtWrV08bNmyw2cdgMMjd3V2StG3bNpUoUUJOTk7asWOHuc3+/fvVtGlTZcyYUU5OTvL09FSlSpW0ZMmSaI8lLCxMI0eOVNGiReXu7q7UqVOrXLlymjt3brydLwAA3jWbO2SO0wsAAAAAAMQvRhACb8i0adPUpUsXi7Lw8HAFBgYqMDBQS5cu1YEDB8zJv//q2LGj5syZI0nKli1brPb55MkTVa1aVX5+fuay06dPq3Pnznr48KEkqV+/fua6kJAQbdmyRXv27NGJEyeUM2dOi1irV6+uXbt2WewjODhYe/fu1d69e7Vt2zatWLEiVrHFlre3t/r27WtR5uvrK19fX23atEmLFi1SkiRJzHWXLl1SmTJldOPGDYs+N2/e1Nq1a7V27VpNmDBB3bt3t7m/zZs3q06dOgoPD7conzFjhjp37myRlHzw4IF27dqlXbt26cSJE/rpp58s+ly/fl3VqlXT6dOnzWWhoaHat2+f9u3bpwULFmj16tVyc3OL20kBAAAAAAAAAOA1MIIQeAPu37+v3r17S5KaNm2q48eP6/HjxwoKCtL8+fPl4eGhO3fuyNvb22b/NWvWaP78+RoyZIjOnDmjwMDAWO3X29tbV69e1YYNG/T48WMFBASoSJEikqRBgwapf//+atu2rS5duqQHDx5ozpw5cnZ21pMnTzR58mSLbc2ePVu7du2Ss7OzJk2apBs3bujJkycKDAw0Jz5Xrlwpf3//Vz1NVi5duqQBAwaoWLFi2rdvn548eaJz586Z97ds2TJNmDDBos/AgQN148YNZc2aVT4+Prp3755CQkLk6+urihUrSpIGDx5sc/ReeHi4WrdurQoVKmj79u168OCBKleurNu3b+vrr7+W0WjUZ599ppMnT+rx48e6fPmyunXrJkkaNWqUrl+/bt5WZGSkmjZtqtOnTytz5sxavny5Hj16pODgYM2fP19p0qTRli1b9OWXX8bb+QIAAAAAAAAAIDZIEAJvwI4dOxQWFqZMmTJp4cKFKlSokFxdXZUmTRq1bt1a/fv3lySdOXPGZv8rV65o1KhRGjZsmPLkySNnZ+dY7Tc4OFhLly5VzZo15erqqqJFi5oTf+Hh4apYsaLmzp2rrFmzysPDQ+3atVO7du1sxrJu3TpJUs+ePfXVV18pffr0cnFxUe7cuTVlyhTlypUrxmN4FSEhIUqTJo22bt2qMmXKyMXFRTlz5tSUKVPUqVMnSS8Sc1GTfevXr5ckTZ06VXXr1lXKlCnl5uamUqVKadGiRebzcuvWLav9PXv2TBkyZNCmTZtUuXJleXh4SJL27NmjJ0+eKF26dFq8eLEKFCggV1dXZcmSRRMmTFC6dOkUERFhMVJz9erV2rdvn5ydnfX333+rSZMmcnd3V4oUKdS6dWtt2bJFLi4uWrx4sY4ePRpv5wwAAAAAAAAAgJdhilHgDfjwww+1fPlypU+fXk5OTlb1Xl5ekmQ1raWJk5OTOnfuHOf9lihRQuXKlbMoK1asmPn/+/TpY9XHVB8SEmJR3rNnT7Vp00alS5e2uS8vLy+dO3cu2mN4Vd27d5enp6dV+U8//aTZs2fr1q1b2rdvnypWrKjIyEj98ccfkqSqVavajNEkuji7dOkiR0fLW6MpIRsZGamnT58qadKk5jqDwaCTJ08qPDzcIs7FixdLkr744gvlz5/faj9FihRRy5YtNXv2bP3111/mkZ0AAAAAgISVrsfMOLW/NaFjAkUCAABgPyQI31ORkZHKmzevSpcurfnz59s7nEQvR44cNtcWDAkJ0YEDBzRp0qQY++fOnVvJkyeP837z5MljVebq6mr+/3z58sVYH1WVKlVsll+7dk1r1qyJ16lFo6pbt67N8rRp06p48eLy8/PT0aNHVbFiRTk4OKhJkyZWbSMjIxUYGKiJEye+dH/Fixe3Kvvoo4/k5uamoKAgVahQQX379lWNGjWUKlUqSVLq1Kmt+pjOh2laU1tKliyp2bNn69SpUy+NCwAAAABgH5s7ZI594/wNEi4QAACAeESC8D21adMmm1Mowr42b94sHx8fHTlyROfOndPNmzdlNBpf2s+UiIorW6MV41L/X8HBwVq+fLm2bdum06dP6/z581YjDeNb1qxZo63Lli2b/Pz8FBQUZFF+4cIFLVu2TPv27dOZM2d08eJFPXv2LFb7s3Wu06VLp5kzZ6pjx446dOiQWrRoIYPBoAIFCqhKlSpq3LixKleubNHH9Plr3ry5mjdvHuM+b9++HavYAAAAAAAA4ovXmG6xbhvUL+YftwMA3j0kCN9D58+f17fffmvvMBDFw4cP1aBBA+3YsUOS5ObmpiJFiqh27doqWrSogoKCNGzYsGj7J0mS5A1FGr1t27apWbNmunPnjiQpc+bMqlChggoWLKjSpUtrzJgxFmvwxZeY1ls0nZeIiAhzmbe3twYOHKjw8HAZDAbly5dP9erVU+HChVWxYkWbU4/a2uZ/NWvWTFWrVtW8efPk4+MjX19fnTx5UidPntTEiRNVpUoVrVq1SilSpLCK6WXCwsJi3RYAAAAAALy9SLoBAN4VJAjfE0eOHNGiRYt06NAhHTp0SJGRkfYOCVH07dtXO3bsUK5cuTR58mRVrVrVIhE1Z84c+wUXCyEhIWratKnu3bun1q1b68cff7SaMnXChAkJsu/Lly+rQIEC0dZJ/zfF5759+9S3b185ODho1KhR6ty5s831C1+Vl5eX+vTpoz59+ujJkyfy8/PTn3/+qenTp2v79u0aOHCgJk+ebI7pxo0bOnjwoEqUKBFvMQAAAAAAAAAA8LpIEL4n9u7dq6lTp9o7DETjr7/+kiSNHz9e1atXt6o3jcp7W+3evVv37t1TunTpNHfuXDk4OFi1Sahj2LVrl80E4d27d83r/BUpUkTS/53nxo0ba8CAATb7vAofHx+dOXNGxYsXN6/F6OrqqkqVKqlSpUoqUKCAunTpoq1bt5r7fPjhh7px44aOHj0abYLw6tWrunnzpjJmzKiMGTO+UmwAgPdbuh4zY912QegPcdp29VlX4xoO3jOMcACAxC0u3wMS3wUAALxvrJ/y453UvHlz+fr6ml8dO3a0d0iIIjg4WJLk4uJiVffgwQPNmDHjDUcUN6b4nZ2dbSYHN2zYoJMnTybIvseOHasnT55YlX///fd6+vSp0qRJo/Lly1vEaes8S9Lo0aNfKQYfHx/169dPAwcOtFlvmgY16sjdTz/9VJL022+/6fHjx1Z9Hj9+rMqVK+ujjz5KkKlZAQAAAAAAAACIDgnC90Tq1KlVoEAB88vLy8veISGKDz74QJL07bffKiAgQE+ePNG1a9c0b948FS9eXIGBgZKkCxcu6M6dO2/dFLGm+K9cuaL+/fvrxo0bevLkiU6ePKk+ffqoUaNG5raHDh3Ss2fP4m3f58+fV61atRQQEKBnz57pwoUL6tq1q3nE7MCBA80JQVOcy5cv14IFCxQcHKyHDx9q7969+vTTTy0ShAcOHIj1OoGmdQv9/PzUq1cvnT9/Xk+fPlVQUJDmz5+vvn37SpJq165t7tO6dWvlyZNHJ06cUMmSJbV27VoFBQUpJCREO3bs0Mcff6zz588rf/78qlev3uufKAAAgPeY15husX4BAAAAAF6OKUZhVrJkyVi1+/zzzyVJ4eHhCRnOW+lVj3nIkCFq2LCh/P39Vbx4cYs6T09PzZgxQ507d9aVK1fk5eWl5cuXq0GDBuYEltFotLnvqGVR/9/ULzIyMsaYw8PDrept7TNPnjxq1qyZli5dqjFjxmjMmDEWfSpVqqQPP/xQ48eP18SJEzV//nwFBQW99LzEFJfJwIEDNXLkSKvzJklNmzZVt27dzO1btmyp3377TefOnVObNm2s2vfs2VMBAQHatWuXmjVrpnr16mnlypVW+/7vOWnYsKEqVaqknTt36rffftNvv/1mte2iRYvq+++/N/dNkiSJli1bptq1a+vEiRM2k4CZMmXS0qVLo31/E0JkZKSePXumW7duvZH9AXg9kWEP4tT+/uPY/fBBEveBd0RcroG4vP9S/F8DxPrCuxRr5KOwWLeNzXER6//fNrHGSlxijUuc0stjTcjvV2KNPWJ9wZ7/JnuXYn2XxPe9NSERKwC8XZ4/f25zBr+EQoIQeANq1qypvXv3avjw4Tp69Kju3LmjzJkzq06dOurbt6/Sp0+v8PBwDR48WJKUKlUqO0dsbfbs2apQoYJmzpyp8+fPy2g0qnDhwmrbtq3at2+vJ0+e6OLFi9q0aZP+97//xdt+hw0bppIlS+q3335TQECAIiMjVbBgQX3xxRdq166dDAaDua27u7v27dunUaNGad26dbp06ZLc3d1VunRp9ejRQ1WqVFFgYKDatGmj06dPK2vWrLGKIUmSJFq3bp2mTJmiFStW6PTp0woNDVXy5MlVoEABNWnSRF9++aV5qlGTAgUKKCAgQOPGjdOaNWt06dIlGY1G5cqVS/Xq1VOvXr3k6ekZb+cKAAAAAID3UYFJ38a67aluoxIwEgAA3h8kCGF24MCBWLWbP3++JMnJySnW2741gTURS5curXXr1kVb37VrV3Xt2tWirGPHjjGuJ5k7d24ZjUar8uHDh2v48OHR9rPV52X7dHJyUrdu3dStm+1pm1xcXLR69epotxsXUa8tJycnNWzYUA0bNoxVXy8vL3l7e8vb29tmfcGCBRUQEGBVHtM5McXRt29f83SisZUuXTr98ssv+uWXX+LUL6E4ODjI1dVV6dKls3coAGLBIVmKOLVPaUwS67bcB94NcbkG4vL+S/F/DRDrC+9SrA7Jk8W6bWyOi1j//7aJNVbiEmtc4pReHmtCfr8Sa+wR6wv2/DfZ+xqrvf+dS6wJ412KFQBelaOj4xtdfow1CAEAAAAAAAAAAIBEhAQhAAAAAAAAAAAAkIgwxSiABOHo+Oq3l3PnzsVjJAAAAAAAAAAAICoShIhRUFCQ7ty5Y1EWERFhp2jwLjly5Ii9QwAAAAAAIFHZ3CFz7Bvnb5BwgQAAgLceCULEaMaMGRo1apRF2ciRI2U0Gu0UEd4VhQoVeuW+Fy9ejL9AAOA/0vWYGaf2tyZ0TKBIAAAAgJjF9d+uCxIoDgAA8P4hQYgYderUSY0aNbIo8/Pzk8FgsFNESAyyZ89OEhoAAAAAAAAAgARCghAx8vLykpeXl0WZv7+/naIBAAAAAAAAAADA63KwdwAAAAAAAAAAAAAA3hxGEL6nBg0apEGDBtk7DAAAACBR8RrTLdZtg/pNSsBIAAAAAACIHglCxCgoKEh37tyxKIuIiLBTNAAAAAAAAABs2dwhc9w65G+QMIEAAN4JTDGKGM2YMUOlSpWyeIWGhspoNNo7NAAAAAAAAAAAALwCRhAiRp06dVKjRo0syvz8/GQwGOwUEQAAAAAAAAC8nZhyHsC7ggQhYuTl5SUvLy+LMn9/fztFAwAA8ObFZaqm6rOuJmAkAAAASGzS9ZgZ67YLEjAOAMD7hwQhAAAAEpW4PGSReNACAAAAxDfWSwQA+yNBCAAAEANGjwEAAAAAAOB9Q4IQMQoKCtKdO3csyiIiIuwUDQAAAAAAAIC3EdOhAsC7hQQhYjRjxgyNGjXKomzkyJEyGo12iggAAAAAAADvujhNMcn0kgAAxDsShIhRp06d1KhRI4syPz8/GQwGO0WEqFatWqWBAwdKkubNm6eSJUvaOSIAAAAAAJAYsc4zAADvFhKEiJGXl5e8vLwsyvz9/e0UDf7rwYMHOnPmjCQpLCzMztEgPl24cEFjx47V5s2bdfXqVTk6Oipfvnxq1qyZunXrpqRJk9o7RAAAAAAAAADAO4oEId6IOE0b8RarPuuqvUNAIrBjxw7Vr19fjx49sij39/eXv7+/FixYoM2bN1sl7wEAAAAAwMvFaa280B/itnGmQwUAvCMc7B0AgFfXvn17GY1GGY1GVa5c2d7hIB6EhISoefPmevTokUqUKKFdu3bp8ePHunz5sn7//XclT55cR48eVYsWLewdKgAAAAAAAADgHUWCEADeIosWLdKtW7eUJk0a/f3336pQoYJcXV2VJUsW9ejRQxs3bpSDg4O2bt0qX19fe4cLAAAAAAAAAHgHkSAE3qCdO3eqSZMmypw5s5ydnZUsWTLlzZtX3bt315UrV6zaz5kzRwaDQd27d1dkZKSGDh2qjBkzKkeOHJKkixcvymAwyGAwWPQbOnSoDAaDxo4dq7CwMPXr10/ZsmVT0qRJVaBAAU2fPt3cdvXq1SpXrpySJ08uLy8vVa9eXQcPHrQZ/7NnzzR+/HiVLVtWnp6ecnR0VMqUKVW+fHlNnjxZz58/j5fzZDquQoUKSZLWrl2rypUrK0WKFPLw8FCZMmU0a9YsGY1Gm/1v376tfv36qVChQnJ3d5eTk5MyZMigevXqacOGDTb7GAwGubu7S5K2bdumEiVKyMnJSTt27DC32b9/v5o2baqMGTPKyclJnp6eqlSpkpYsWRLtsYSFhWnkyJEqWrSo3N3dlTp1apUrV05z5861eb62bNkiSWrSpIlSpkxpVV+2bFlVqFBBkrRr165o9wsAAAAAAAAAQHRYgxAxCgoK0p07dyzKIiIi7BTNu23atGnq0qWLRVl4eLgCAwMVGBiopUuX6sCBA+bk33917NhRc+bMkSRly5YtVvt88uSJqlatKj8/P3PZ6dOn1blzZz18+FCS1K9fP3NdSEiItmzZoj179ujEiRPKmTOnRazVq1e3SkoFBwdr79692rt3r7Zt26YVK1bEKrbY8vb2Vt++fS3KfH195evrq02bNmnRokVKkiSJue7SpUsqU6aMbty4YdHn5s2bWrt2rdauXasJEyaoe/fuNve3efNm1alTR+Hh4RblM2bMUOfOnS2Skg8ePNCuXbu0a9cunThxQj/99JNFn+vXr6tatWo6ffq0uSw0NFT79u3Tvn37tGDBAq1evVpubm7m+nPnzkmSChYsGO05SZcunaQX7xcAAAAAAAAAAHHFCELEaMaMGSpVqpTFKzQ0NNqRW7Dt/v376t27tySpadOmOn78uB4/fqygoCDNnz9fHh4eunPnjry9vW32X7NmjebPn68hQ4bozJkzCgwMjNV+vb29dfXqVW3YsEGPHz9WQECAihQpIkkaNGiQ+vfvr7Zt2+rSpUt68OCB5syZI2dnZz158kSTJ0+22Nbs2bO1a9cuOTs7a9KkSbpx44aePHmiwMBAc+Jz5cqV8vf3f9XTZOXSpUsaMGCAihUrpn379unJkyc6d+6ceX/Lli3ThAkTLPoMHDhQN27cUNasWeXj46N79+4pJCREvr6+qlixoiRp8ODBNkfvhYeHq3Xr1qpQoYK2b9+uBw8eqHLlyrp9+7a+/vprGY1GffbZZzp58qR5XcBu3bpJkkaNGqXr16+btxUZGammTZvq9OnTypw5s5YvX65Hjx4pODhY8+fPV5o0abRlyxZ9+eWXFjEMHz5cixcvVp06dWyeE6PRqCNHjkhStMlkAAAAAAAAAABiQoIQMerUqZP8/PwsXm5ublZTWiJmO3bsUFhYmDJlyqSFCxeqUKFCcnV1VZo0adS6dWv1799fknTmzBmb/a9cuaJRo0Zp2LBhypMnj5ydnWO13+DgYC1dulQ1a9aUq6urihYtak78hYeHq2LFipo7d66yZs0qDw8PtWvXTu3atbMZy7p16yRJPXv21FdffaX06dPLxcVFuXPn1pQpU5QrV64Yj+FVhISEKE2aNNq6davKlCkjFxcX5cyZU1OmTFGnTp0kvUjMRU32rV+/XpI0depU1a1bVylTppSbm5tKlSqlRYsWmc/LrVu3rPb37NkzZciQQZs2bVLlypXl4eEhSdqzZ4+ePHmidOnSafHixSpQoIB5XcAJEyYoXbp0ioiIsBipuXr1au3bt0/Ozs76+++/1aRJE7m7uytFihRq3bq1tmzZIhcXFy1evFhHjx4196tTp46aN28ebfJv+vTpCgwMlIuLi2rWrPmaZxgAAAAAAAAAkBgxxShi5OXlJS8vL4uy+Bwhllh8+OGHWr58udKnTy8nJyeretM5/u+0liZOTk7q3LlznPdbokQJlStXzqKsWLFi5v/v06ePVR9T/X+nr+zZs6fatGmj0qVL29yXl5eXzp07F+0xvKru3bvL09PTqvynn37S7NmzdevWLe3bt08VK1ZUZGSk/vjjD0lS1apVbcZoEl2cXbp0kaOj5a3RlJCNjIzU06dPlTRpUnOdwWDQyZMnFR4ebhHn4sWLJUlffPGF8ufPb7WfIkWKqGXLlpo9e7b++usv88jO6ERGRsrb21uDBg2S9OL9yJAhQ4x9AAAAAAAAAACwhQQh8AbkyJHD5oiwkJAQHThwQJMmTYqxf+7cuZU8efI47zdPnjxWZa6urub/z5cvX4z1UVWpUsVm+bVr17RmzZoESxzXrVvXZnnatGlVvHhx+fn56ejRo6pYsaIcHBzUpEkTq7aRkZEKDAzUxIkTX7q/4sWLW5V99NFHcnNzU1BQkCpUqKC+ffuqRo0aSpUqlSQpderUVn1M58M0raktJUuW1OzZs3Xq1KkYY9q5c6d69eqlw4cPS5JatGihESNGvPRYAOBttrlD5li3rT7ragJGAgAAAAAAkPiQIATeoM2bN8vHx0dHjhzRuXPndPPmzVit52hKRMWVrdGKcan/r+DgYC1fvlzbtm3T6dOndf78eauRhvEta9as0dZly5ZNfn5+CgoKsii/cOGCli1bpn379unMmTO6ePGinj17Fqv92TrX6dKl08yZM9WxY0cdOnRILVq0kMFgUIECBVSlShU1btxYlStXtuhjmsK0efPmat68eYz7vH37ts3yGzduqFevXlq6dKkkyd3dXWPGjDGvwQgAQGLhNaZbrNsG9Yv5h1cAAAAAXuDf2UDiRoIQeAMePnyoBg0aaMeOHZIkNzc3FSlSRLVr11bRokUVFBSkYcOGRds/SZIkbyjS6G3btk3NmjXTnTt3JEmZM2dWhQoVVLBgQZUuXVpjxoyxWIMvvsS03qLpvERERJjLvL29NXDgQIWHh8tgMChfvnyqV6+eChcurIoVK9qcetTWNv+rWbNmqlq1qubNmycfHx/5+vrq5MmTOnnypCZOnKgqVapo1apVSpEihVVMLxMWFmZVtn79erVp00b37t1TkiRJ1L59ew0fPpxpRQEAAAAAAAAAr40EIfAG9O3bVzt27FCuXLk0efJkVa1a1SIRNWfOHPsFFwshISFq2rSp7t27p9atW+vHH3+0mjJ1woQJCbLvy5cvq0CBAtHWSf83xee+ffvUt29fOTg4aNSoUercubPN9QtflZeXl/r06aM+ffroyZMn8vPz059//qnp06dr+/btGjhwoCZPnmyO6caNGzp48KBKlCgRp/0sWrRIbdu2VUREhIoUKaK5c+e+dI1CAAAAAAAAAABiy8HeAQCJwV9//SVJGj9+vKpXr241Ss00Ku9ttXv3bt27d0/p0qXT3Llzba6nmFDHsGvXLpvld+/eNa/zZ0qemc5z48aNNWDAAKvk4N27d18pBh8fH40dO1bbt283l7m6uqpSpUoaP368fvvtN0nS1q1bzfUffvihJOno0aPRbvfq1avy9/fX9evXzWX//POPOnTooIiICLVs2VIHDhwgOQgAAAAAAAAAiFeMIATegODgYEmSi4uLVd2DBw80Y8aMNxxR3Jjid3Z2loOD9e8KNmzYoJMnTybIvseOHav27dvL1dXVovz777/X06dPlSZNGpUvX94iTlvnWZJGjx79SjH4+PhoxowZKlWqlHx9fa3qTdOgRkZGmss+/fRTbdiwQb/99ptatmyppEmTWvR5/PixKleurPPnz+vPP/9Uo0aNzDE+ffpUpUuX1vz5822ebwB4G6XrMTNO7RckUBwAAAAAEJ82d8gctw75GyRMIAAQz3jyjBgFBQXp9OnTFq+4rK2GFz744ANJ0rfffquAgAA9efJE165d07x581S8eHEFBgZKki5cuKA7d+5YJJreBqb4r1y5ov79++vGjRt68uSJTp48qT59+piTW5J06NAhPXv2LN72ff78edWqVUsBAQF69uyZLly4oK5du2rq1KmSpIEDB5oTgqY4ly9frgULFig4OFgPHz7U3r179emnn1okCA8cOBDra9m0bqGfn5969eql8+fP6+nTpwoKCtL8+fPVt29fSVLt2rXNfVq3bq08efLoxIkTKlmypNauXaugoCCFhIRox44d+vjjj3X+/Hnlz59f9erVM/dbs2aNJOmbb74hOQgAAAAAAAAASBCMIESMZsyYoVGjRlmUjRw5Ukaj0U4RvZt+/PFH1a1bV/7+/ipevLhFnaenp2bNmqUvvvhCV65ckZeXl1atWqWGDRvaJ1gbChYsqBYtWmjx4sUaM2aMxowZY1FfuXJlFS1aVL/++qsmTpyo+fPnm0fzva7vv/9eP/30k9V5k6RmzZqpZ8+e5r/btWun8ePH6+zZs2rTpo1V+969e+vQoUPauXOnmjVrpgYNGmj16tUvjaFp06aaNm2aduzYod9++808pWhUxYoV07Bhw8x/u7q6atWqVapevbpOnDhhkQQ0yZQpk/788085Or64FV+6dMk8DWqLFi3UokWLGOP69ddfLY4fAAAAAAAALxeXGVCY/QTA+4rhKYhRp06d5OfnZ/Fyc3OTwWCwd2jvlFq1asnPz09169ZVpkyZ5OLiopw5c6pnz546ffq0Pv/8c02ZMkWpU6dW6tSplSpVKnuHbGXevHmaMmWKihUrJg8PDyVPnlzlypXTjBkztHXrVv30009q1KiRXF1dlTNnznjb7/Dhw+Xj46PKlSsrefLkcnNzU6lSpTRz5kwtXrzYYpSdu7u7Dhw4oH79+ilfvnxydXVVmjRpVL9+fW3dulXe3t6aPn26ihUrJldXV2XNmjVWMSRJkkSbNm3SuHHjVLp0aXl4eChJkiTy9PRUuXLlNH78eO3fv99qzcMCBQro+PHjGjhwoPLnz6+kSZPK1dVVhQsX1vfff68TJ04oX7585vZXrlyJl3MGAAAAAAAAAEBMGEGIGHl5ecnLy8uizN/fP87bqT7ranyF9M4qUaKEfHx8oq3/8ssv9eWXX1qUtW/fXu3bt4+2T/bs2W2O5hw6dKiGDh0abb+YRoBGt09HR0d16dJFXbp0sdkvWbJk+vPPP6Pd7uuoW7eu6tatG6u2np6eGj16dLTrDebJk0eHDh2yKn/ZqFhnZ2f16tVLvXr1ilUcJqlSpdKIESM0YsSIl7YtX748o3MBAAAAAAAAAAmOBCEAAACQCHmN6RbrtkH9JiVgJAAAAAAA4E1jilEAAAAAAAAAAAAgEWEEIYAE4ej46reXc+fOxWMkAAAAAAAAAAAgKhKEABLEkSNH7B0CAAAAAAAAAACwgQQhgARRqFChV+578eLF+AsEAAAAAAAAAABYIEEI4K2TPXt2GY1Ge4cBAAAAAAAAAMB7ycHeAQAAAAAAAAAAAAB4cxhBiBgFBQXpzp07FmURERF2igYAAAAAAAAAAACvixGEiNGMGTNUqlQpi1doaCjTPwIAAAAAAAAAALyjGEGIGHXq1EmNGjWyKPPz85PBYLBTRAAAAAAAAAAAAHgdJAgRIy8vL3l5eVmU+fv72ykaAAAAAAAAAAAAvC6mGAUAAAAAAAAAAAASERKEAAAAAAAAAAAAQCJCghAAAAAAAAAAAABIREgQAgAAAAAAAAAAAIkICUIAAAAAAAAAAAAgESFBCAAAAAAAAAAAACQiJAgBAAAAAAAAAACARIQEIZDI3L9/X99//70KFy4sd3d3ubq6Km/evOrZs6euXbtm7/AAAAAAAAAAAEACc7R3AEgcvMZ0s3cI8SKo3yR7h/Babt68qfLly+v8+fMW5YGBgQoMDNSCBQu0efNmFS1a1E4RAgAAAAAAAACAhMYIQiAR6dmzp86fP68UKVJo+vTpunLlioKDg7VhwwblyZNHd+/e1Weffabnz5/bO1QAAAAAAAAAAJBASBACiURwcLBWrlwpSZo3b546deqkzJkzK0WKFKpZs6bWrl0rFxcXnTt3Ttu3b7dztAAAAAAAAAAAIKEwxShiFBQUpDt37liURURE2CkavI6AgAA9f/5cHh4eqlu3rlV97ty59eGHH8rPz0/Hjx9X9erV7RAlAAAAAAAAAABIaIwgRIxmzJihUqVKWbxCQ0NlNBrtHdo7Z8eOHTIYDObk3LRp01S4cGElTZpUmTNnVt++ffXkyRNJ0okTJ9SwYUOlTp1ayZMnV/HixbVo0SKb2z18+LCaN2+uDBkyyNnZWRkyZFDz5s11+PBhi3a3bt2SJGXLlk0ODrY/+smTJ5ckm+/vo0ePNGTIEBUsWFDJkiWTh4eHypYtq5kzZ3I9AAAAAAAAAADwDmEEIWLUqVMnNWrUyKLMz89PBoPBThG9H7755hv9/vvv5r+vXbsmb29v/fPPP+rfv79q1qypx48fm+sDAgLUqlUrSVLLli3N5XPnzlXHjh0tRnXevHlTS5cu1Z9//qklS5bo008/lSS1aNFCLVq0iDamR48e6ciRI5KkwoULW9RdunRJVatW1YULFyzK9+/fr/3792vTpk1asmRJtIlHAAAAAAAAAADw9uBpPmLk5eWl/PnzW7ySJEli77DeaXv37tWUKVM0ceJEPXz4UJcvX1bz5s0lSevWrVONGjVUqFAh+fv7KywsTDt37lTWrFklSd7e3ubtBAQE6IsvvlBERIQ+//xznT17VmFhYfL391elSpUUHh6ujh076v79+9HG8vz5cwUFBWnbtm1q0KCB7ty5o5IlS6patWrmNhEREWratKkuXLigvHnzavPmzQoLC9OVK1c0dOhQGQwGLV++XHPnzk2gMwYAAAAAAAAAAOLTW50gvHbtmlauXKnly5fr9u3b9g4HiBfBwcEaOnSounXrpuTJkytLliyaOXOmPD09JUlubm7asGGDihcvrqRJk6pixYoaOXKkJOnMmTPm7QwePFjPnz/Xp59+qlmzZilXrlxKmjSpihcvLh8fH2XKlEnBwcFatWqVzThCQkLk5OSktGnT6uOPP9b27dvVpEkTrV+/3mIk4J9//qmDBw8qefLk2rp1q6pVq2aeFvWHH35Qjx49JEmzZ89OoDMGAAAAAAAAAADik90ThNevX1fv3r1VoUIF3bt3z1y+fPlyFS9eXB07dlSnTp1UuHDhaNdgA94lBoPBnFQzSZYsmfLmzStJat++vVKnTm1RX6xYMUlSaGioJOnhw4fauHGjpBeJwv9Knjy5OnXqpLx585rXHowNf39/7d2716Js6dKlkqQOHTooU6ZMVn06duyovHnzmtdPBAAAAAAAAAAAbze7rkF48+ZNValSxZzAMK2jdu/ePfXs2VOPHz9WlixZ5ODgoEuXLqlHjx4qUqSIChYsaM+wgdeSIUMGJU+e3Krc1dVVkpQvX75o60wCAgIUGRkpT09Pffjhhzb388MPP+iHH36INg53d3cZjUaFhIQoMDBQ3t7eWrRokT799FNt3LjRPM2ov7+/JKlKlSo2t/PBBx/on3/+iXY/AAAAAAAAABLe5g6Z49Yhf4OECQTAO8GuIwh/+eUX3bx5UxkzZpS3t7d5isXly5crJCRERYsW1ZEjR3Ts2DE1bNhQz58/15QpU+wZMvDanJycXqteknnK3cyZ4/ilb4O7u7uKFSumhQsXqnHjxoqIiNCoUaMSZF8AAAAAAAAAAMD+7Jog3Lp1qwwGg6ZMmaKOHTuaEyNbtmyRwWBQx44d5ej4YpBjv379JEm7d++2W7zA28I02jZJkiTxut22bdtKko4ePZrg+wIAAAAAAAAAAPZh1ylGb9y4IUn66KOPzGVGo1F+fn6SpMqVK5vLc+fObdEHSMxMaxTG5fNQt25d7dixQ999950GDhxos03atGklSY8ePbLY140bN3Tjxo1opzMFAAAAAAAAgITiNaZbrNsG9ZuUgJEA7w+7JgidnJwUHh6up0+fKlmyZJKkY8eO6cGDB8qaNauyZMlibvvkyRN7hQm8dYoUKSLpxfSfZ86cUd68ea3a/Prrrxo8eLBq1aql5cuXK3PmzAoNDdXp06ej3e6ZM2ckWU4n+uGHH+rGjRvatWuXatWqZdXn1q1bypUrl4xGoy5dumROXgIAAAAAAAB4Pel6zIx12wUJGAeA949dpxjNmTOnJGn79u3mspUrV0qSqlSpYtH24MGDkqT06dO/oeiAt1e6dOlUtmxZSdKPP/5oVf/8+XPNnTtXoaGhKlq0qCSpWrVqkqQ1a9YoKCjIZp9ff/1VklSjRg1zeaNGjSRJ06dP161bt6z6zZs3TyEhIcqYMSPJQQCxtrlD5li/AAAAAAAAAMQvuyYIGzRoIKPRqN69e2vmzJmaOHGipk6dKoPBoCZNmkiSwsPDtXXrVvXu3VsGg0FlypSxZ8jAW+PHH3+UwWDQokWL1LFjR509e1ZPnz7VqVOn1Lx5cx09elRubm76/PPPJb34vGXPnl0PHjxQ2bJl9ddff+nWrVt68OCBdu3apSpVqujo0aNyd3dX//79zftp06aN8uTJo3v37qlKlSravHmzHj9+rFu3bmnSpEkaMmSIJKlHjx52OQ8AAAAAAAAAACBu7DrFaLdu3bRy5UqdOnVKffr0kfRiDcKKFSuqYsWKkqSpU6dq8ODBMhqNcnJyIgkB/H8ff/yxxowZo759+2rWrFmaNWuWRb2zs7PmzZunDBkySHoxpe/SpUtVs2ZNnTt3Tg0bNrTapoeHh5YvX67s2bOby1xdXfXnn3+qWrVqOn36tMXoQpPPPvtM3brFfh5wAAAAAAAAAABgP3YdQZg0aVJt2LBBX331lQoUKKAiRYro66+/1pIlSyzaGY1G5c6dW0uWLFGhQoXsFC3w9unTp492796thg0bysvLS46OjsqQIYNatGihAwcO6NNPP7VoX7JkSR09elRff/218uTJI1dXV7m6uipv3rz65ptvdPz4cZsJwIIFC+r48ePq06ePcufOLRcXFyVPnlzlypXTrFmztGTJEjk42PV2AgAAAAAAAAAAYsmuIwglydPTUyNHjoy2vlWrVmratClrD77jgvpNsncIdle5cmUZjcZo63fs2BFtXfbs2aPtW758eZUvXz7WcWTJkkXjx4+PdXuTNGnSaOzYsRo7dmyc+wIAAAAAAAAAgLeHXROEixYtkiS1bNky2japUqUy///ixYuVIkUK1a5dO8FjAwAAAAAAAAAAAN5Hdk0Qdu3aVQ4ODjEmCKMaMGCAHBwcdPHixYQNDAAAAAAAAAAAAHhPvdEE4ZUrV3T58mWLMqPRqH379sU49aIkXb58WY8ePZKLi0tChggAAAAAAAAAAAC8195ognDBggX65ZdfzH8bDAZJivWUoUajUYUKFUqQ2AAAAAAAAAAAAIDE4I0mCFOkSKEsWbKY/758+bIMBoNFWXQMBoOyZ8+uUaNGJWSIAAAAAAAAAAAAwHvtjSYIv/rqK3311Vfmv1OkSCFJOn78+JsMA3EQFBSkO3fuWJRFRETYKRoAAAAAAAAAAAC8rjeaIPyvFi1amKcZxdtpxowZVqM2R44c+dI1IwEAAAAAAAAAAPB2smuCcOrUqfbcPWKhU6dOatSokUWZn58fiV0AAAAAAAAAAIB3lF0ThCbBwcEKDAxUeHh4rNqXK1cugSOCiZeXl7y8vCzK/P397RQNAAAAAAAAAAAAXpfdE4TDhg3ThAkT9Pz581i1NxgMun//fgJHBQAAAMSd15husW4b1G9SAkYCAAAAAAAQPbsmCOfMmaNx48aZ/06bNq1cXV3tGBEAAAAAAAAAAADwfrNrgnDmzJmSpCJFimju3LnKkSOHPcMBAAAAAAAAAAAA3nt2TRCeOXNGBoNB48aNIzkIAMA7LF2PmXFqvyCB4gAAAAAAAADwcg723HmyZMkkSYULF7ZnGAAAAAAAAAAAAECiYdcEYdGiRSVJ165ds2cYAAAAAAAAAAAAQKJh1wRhv379lCRJEo0YMcKeYQAAAAAAAAAAAACJhl3XICxbtqxmz56tbt26qUGDBho0aJCKFy8uR0e7hoVYMBqNunDhgr3DABBHz549k7Ozs73DAAAAAAAAAADYkV0zcQ0aNJAkpUuXTjt37tTOnTvl4OCg9OnTx5gkPHbs2JsKETbcu3dPvr6+qlmzpr1DARBHzs7OcnJysncYAAAAAAAAAAA7smuCcMeOHVZlERERMa5JaDAYEjAixMbChQvl4OCgr776yt6hAAAAAAAAAAAAII7smiBct26dPXcPAAAAAAAAAAAAJDp2TRCWL1/enrsHAAAAAAAAAAAAEh0HewcAAAAAAAAAAAAA4M2x6wjCK1euvFK/LFmyxHMkAAAAAAAAAAAAQOJg1wRh4cKF49zHYDDo/v37CRANAAAAAAAAAAAA8P6za4LQaDTGum369OmVPn36BIwGAAAAAAAAAAAAeP/ZNUH44MGDaOueP3+uy5cv68CBA/L29tb169fVp08f1a9f/w1GCAAAAAAAAAAA4tPmDpnj1iF/g4QJBEjEHOwdQHQcHR31v//9T82bN9f+/fv10UcfqWPHjvL397d3aAAAAAAAAAAAAMA7661NEEbl6Oio4cOH69mzZxozZoy9wwEAAAAAAAAAAADeWXadYjQu8ubNK0k6cOCAnSMBAADAm+Q1pluc2gf1m5RAkQAAAAAAALwf3okRhJJ07tw5SVJoaKidIwEAAAAAAAAAAADeXe/ECMKHDx9q4MCBkqQcOXLYORoAAAAAAAAAABBVuh4zY912QQLGASB27JogrFu37kvbPHnyRP/8849CQkJkMBjUqlWrNxAZAAAAAAAAAAAA8H6ya4Jw9+7dcWr/2WefqXv37gkUzZtlNBo1c+ZMzZ8/X2fPnpWjo6M++OADdevWTbVq1bJ3eAAAAAAAAAAAAHhP2TVBOHny5Fi1c3Z2VqFChZQ/f/4EjujNMBqNatOmjdasWWNRvmvXLu3atUvfffedBgwY8MrbDwwMVIkSJTRmzBh17tz5dcMFAAAAAAAAAADAe8SuCcLEOl3opEmTtGbNGrm4uOiXX35RkyZN9PjxY02cOFHjx4/XiBEjVK5cOZUvX/6Vtj937tx4jhgAAAAAAAAAAADvCwd7B5DYPH36VL/99psk6aefflKHDh3k4eGhdOnSafjw4WrVqpWMRqPGjBnzStvfvHmzpk+fHo8RAwAAAAAAAAAA4H1i1xGEUe3du1dr1qzR8ePHdffuXUVGRipVqlQqVKiQ6tevr0qVKtk7xHixd+9e3b59WylTptTnn39uVd+rVy8tXLhQu3btUnBwsDw9PV+6zb/++kt///239u/fr3PnziVA1AAAAAAAAAAAAHhf2D1BeOvWLX3xxRfavXu3pBfr80Xl5+enmTNnqnz58vrjjz+UPn16e4QZb/bs2SNJqlSpkpydna3q8+TJo6xZs+ry5cvav3+/atWq9dJtLlmyROvWrYv3WAEAAAAAAAAAAPD+sWuC8PHjx6pXr54CAwNlMBhUo0YNVapUSZkyZZLBYND169e1c+dObdy4UXv27FGDBg20Y8cOJU2a1J5hv5azZ89KkgoVKhRtm8KFC+vy5cs6e/ZsrBKEo0eP1uDBg81/d+3aVYcPH379YAEAAAAAAAAAAPDesWuCcMqUKTpz5oxSp06tpUuX6qOPPrJq06VLF/n5+alZs2Y6c+aMpk6dql69etkh2vhx5coVSVKmTJmibZMxY0ZJ0uXLl2O1zSxZslj87ebm9orRAQAAAAAAAAAA4H3nYM+d//XXXzIYDBo5cqTN5KBJqVKlNGLECBmNRq1ateoNRhj/QkNDJUnu7u7RtjHVmdoCAAAAAAAAAAAA8cWuIwjPnz8vSbGaRrNu3brq2rWruc+76unTp5Jkc/1BEycnJ0kvpmB9k0qWLBmrdhcuXFD27Nl169atBI4IAPCuiAx7EKf29x9HxLptfH/fEOsL71KskY/C4rTtlx3b2xJrbN6DuMQalzglYo0tYn2BWGOPWGOH74EXiDV2iDX2iJV7a1wQa+wQ6wvvW6zA2+j58+dycHhz4/rsOoLw+fPnkiRHx5fnKU1tIiMjEzSmhObi4iLp/xKFtsQmiQgAAAAAAAAAAAC8CruOIMyaNasCAwO1c+fOl44i3LlzpyTr9fbeNab1AUNCQqJtY6p702sJHjhwIFbtSpYsKQcHB6VLly6BIwIAvCsckqWIU/uUxiSxbhvf3zfE+sK7FKtD8mRx2vbLju1tiTU270FcYo1LnBKxxhaxvkCssUesscP3wAvEGjvEGnvEyr01Log1doj1hfctVuBt5Ojo+EYHydl1BGGtWrVkNBo1YMAAXblyJdp2V69e1YABA2QwGFS7du03GGH8MyU4r127Fm2b69evS5IyZ878RmICAAAAAAAAAABA4mHXEYTffPONFi9erMuXL6t06dJq06aNKlWqpIwZM8pgMOjatWvatWuX5s+fr0ePHil9+vT6+uuv7Rnya8udO7ck6cSJE9G2OXnypCQpT548byQmAAAAAAAAAAAAJB52TRCmSpVKa9asUatWrXTu3DlNnTpVU6dOtWpnNBqVM2dOLVy4UKlSpbJDpPGnQoUKGjt2rHbu3Klnz55ZrTN49uxZXb58WUmSJFG5cuXsFOX/CQoK0p07dyzKnj59yvqIAAAAAAAAAAAA7yi7JgglKV++fNq3b5+WLl2qtWvX6vjx47p7966kFwnEwoULq27dumrWrJlcXV3tHO3rK1eunNKlS6dbt25p7ty56tSpk0X977//LkmqXLnyW5EMnTFjhkaNGmVV7uXlZYdoAAAAAAAAAAAA8LrsniCUJBcXF7Vt21Zt27a1dygJztnZWb169dK3336r7777Tq6urmrYsKHCwsI0ZcoUzZ07Vw4ODvr2228t+hUvXlySVK9ePQ0dOvSNxdupUyc1atTIoqx58+aMIASAt9DmDrFfu7b6rKsJGAkAAAAAAACAt9lbkSCUpEuXLunSpUuqWLGiRfm0adNUtGhRlSxZ0k6Rxb+uXbvK19dXq1evVrdu3dStWzeL+mHDhqlUqVIWZWfPnpUk3bx5843FKb0YKfjf0YIuLi5ycHB4o3EAAAAAAAAAAAAgftg9y/Pvv/+qTp06KlKkiPr06WNVP2zYMNWoUUNVqlTRv//+a4cI45/BYNDcuXP166+/qmjRonJzc5Onp6cqVaqk5cuX65tvvrF3iAAAAAAAAAAAAHhP2XUEYVBQkD755BPdvn1bRqNROXLksGpTpUoVbd26VQEBAapdu7b27Nmj1KlT2yHa+GUwGNSxY0d17NgxVu0fPnwY622vX7/+VcMCAAAAAAAAAADAe86uIwi9vb1169YtZc2aVbt27dKyZcus2ixcuFAHDx5UwYIFdePGDf366692iDTxCgoK0unTpy1eT58+VUREhL1DAwAAAAAAAAAAwCuwa4Jw48aNMhgMGjNmjIoUKRJtuyxZsmj06NEyGo2MjnvDZsyYoVKlSlm8/v33X927d8/eoQEAAAAAAAAAAOAV2HWK0WvXrkmSypUr99K2xYoVkyRdvXo1QWOCpU6dOqlRo0YWZc2bN5ezs7OdIgIAAAAAAAAAAMDrsGuCMFmyZHrw4IGePn0qd3f3GNuGhYVJklxdXd9EaPj/vLy85OXlZVHm4uIiBwe7Dj4FAAAAAAAAAADAK7Jrlsc0rejixYtf2tbUpmDBggkaEwAAAAAAAAAAAPA+s2uCsGPHjjIajRo2bJhmzJihyMhIm+3mzZunH3/8UQaDQW3btn3DUQIAAAAAAAAAAADvD7tOMdqgQQO1a9dOc+fOVb9+/TRq1CiVKVNGGTNmVJIkSXTz5k35+vrqxo0bMhqNatCggVq0aGHPkAEAAPD/2Lvv6Cjqto3j1yQkoaOEgPQiRZAAgoJIV0CqAjaKhSIqTUCpoigWDKKiYGwBAUVQURSQXqRLE6mCBhACBEIahBISSPb9g3f3YdlUyOxm3O/nHM5znim7V+Jm5t65Z34/AAAAAAAAWJpHG4SSNHnyZFWvXl3vvfeeYmJitHDhQkmSYRiy2WySrs5VOGjQII0YMcKTUb1SdHS0YmJinJYlJSXJ39/fQ4kAAAAAAAAAAABwMzzeIJSkfv36qXfv3vrtt9/0559/Kjo6WqmpqSpatKiCg4P1wAMPqHDhwmnue/z4cZUsWVK+vr5uTu0dwsLCFBIS4rI8KCjIA2kAAAAAAAAAAABws3JFg1CSAgIC1KZNG7Vp0yZb+9WuXVsbN27UHXfcYVIy79a3b1917tzZaVnXrl15ghAAAAAAAAAAAMCick2D8EbZhyGFOYKCglyeFgwICJCPj4+HEgEAgJwQNHFAtraPHh5qUhIAAAAAAAC4G10eAAAAAAAAAAAAwIvQIAQAAAAAAAAAAAC8CA1CAAAAAAAAAAAAwIvQIAQAAAAAAAAAAAC8SB5PB0DuFh0drZiYGKdlSUlJ8vf391AiAAAAAAAAAAAA3AwahMhQWFiYQkJCXJYHBQV5IA0AAAAAAAAAAABuFg1CZKhv377q3Lmz07KuXbvyBCEAAAAAAAAAANcImjggW9tHDw81KQmQORqEyFBQUJDL04IBAQHy8WH6SgAAAAAAAAAAACuiywMAAAAAAAAAAAB4ERqEAAAAAAAAAAAAgBehQQgAAAAAAAAAAAB4ERqEAAAAAAAAAAAAgBexfIOwXLly8vPz83QMAAAAAAAAAAAAwBLyeDrAzdq5c6enI/ynRUdHKyYmxmlZUlKS/P39PZQIAAAAAAAAAAAAN8PjDcIjR45o6tSpCg8P14ULFzLd3jAMLVy40A3JIElhYWEKCQlxWR4UFOSBNAAAAAAAAAAAALhZHm0Q7tixQ+3atdOlS5dks9mytI9hGCanwrX69u2rzp07Oy3r2rUrTxACAAAAAAAAAABYlEcbhOPGjVNiYqL8/f3VvXt31a5dWwEBAZ6MhOsEBQW5PC0YEBAgHx/LT18JAAAAAAAAAADglTzaINyzZ48Mw9DkyZPVrVs3T0YBAAAAAAAAAAAAvIJHHwNLSkqSJHXs2NGTMQAAAAAAAAAAAACv4dEGYY0aNSRJZ8+e9WQMAAAAAAAAAAAAwGt4tEE4ePBg2Ww2vfPOO56MAQAAAAAAAAAAAHgNj85B2KFDB7311lsaO3asjh07pgEDBqhq1ary8/PLcL+yZcu6KSEAAAAAAAAAAADw3+LRBqEkGYahPHnyaP369Vq/fn2Wto+Pj3dDMgAAAAAAAAAAAOC/x6MNwhkzZui1116TJNlstiztk9XtAAAAAAAAAAAAALjyaIPw008/lc1mU3BwsD744APVqVNHAQEBnowEAAAAAAAAAAAA/Kd5tEF49OhRGYahzz77TMHBwZ6MgnRER0crJibGaVlSUpL8/f3dliFo4oAsbxs9PNTEJAAAAAAAAAAAANbn0QZhUFCQjh8/rmrVqnkyBjIQFhamkJAQl+VBQUEeSAMAAAAAAAAAAICb5ePJN+/UqZMkacOGDZ6MgQz07dtXW7ZscfpXsWJFFS1a1NPRAAAAAAAAAAAAcAM8+gThmDFjtGnTJg0cOFAzZsxQ/fr1PRkHaQgKCnJ5WjAgIEA+Ph7tLQMAAAAAAAAAAOAGebRBOG3aNLVt21ZTpkxR69atddddd6ly5cry8/NLdx/DMBQayjxzAAAAAAAAAAAAwI3w+BOEhmHIZrNJknbs2KEdO3ZkuA8NQgAAAAAAAAAAAODGebRBOHLkSBmG4ckIAAAAAAAAAAAAgFfxaIPwlVde8eTbAwAAAAAAAAAAAF7Hx5NvHhISogkTJngyAgAAAAAAAAAAAOBVPPoE4ccff6zExEQ9++yzCgwM9GQUAAAAAAAAAAAAwCt4tEHYpEkTLV++XBs2bNDDDz/sySgAAOQ6JQZNy9b2s0zKAQAAAAAAAOC/xaNDjE6cOFElSpTQ66+/rhMnTngyCgAAAAAAAAAAAOAVPPoEYXx8vD766CMNGzZM99xzj9q0aaO77rpLt956q3x80u9ddu/e3Y0pAQAAAAAAAAAAgP8OjzYImzVrJsMwJEk2m03z5s3TvHnzMt2PBiEAAAAAAAAAAABwYzzaIGzUqJGjQQgAAAAAAAAAAADAfB5tEC5evNiTb48siI6OVkxMjNOypKQk+fv7eygRAAAAAAAAAAAAboZHG4TI/cLCwhQSEuKyPCgoyANpAAAAAAAAAAAAcLNyVYMwPj5ee/fuVWxsrFJTU1W0aFEFBwcrMDDQ09G8Vt++fdW5c2enZV27duUJQgAAAAAAAAAAAIvKFQ3CDRs2KCQkRBs2bEhzfcOGDTV69Gg1bdrUzckQFBTk8rRgQECAfHx8PJQIAAAAAAAAAAAAN8PjXZ7Q0FB17NhR69evl81mU+HChXXHHXeoevXqKlKkiGw2mzZt2qSHH35YoaGhno4LAAAAAAAAAAAAWJpHnyDctm2bxowZI5vNpgcffFCvvPKK6tSp47TNrl279NZbb2nFihV69dVXVb9+fd1zzz2eCQwAAAAAAAAAALzGit5lsr5x9YfNCwLkMI82CENDQ2Wz2dSlSxdNnz49zW1q166tH3/8UU899ZQWLFig0NBQzZgxw71BAQAAsiBo4oBsbR89nNERAAAAAAAA4H4eHWJ08+bNMgxDo0aNynTbMWPGSJJ+//13s2MBAAAAAAAAAAAA/1kebRDGxsZKkm6//fZMt7VvExcXZ2omAAAAAAAAAAAA4L/Mow3CwoULS5KOHz+e6bYnTpxw2gcAAAAAAAAAAABA9nm0QXjXXXdJujoXYWbs29SrV8/UTAAAAAAAAAAAAMB/mUcbhH379pXNZlNYWJiGDx/uGHL0WrGxsRoxYoS+/PJLGYahPn36eCApAAAAAAAAAAAA8N+Qx5Nv/uCDD+qFF17Q559/rrCwME2fPl133nmnSpYsKcMwFBkZqX379unKlSuSpOeee04PPvigJyMDAAAAAAAAAAAAlubRBqEkTZgwQcHBwZowYYIiIiK0c+dO7dy502mbsmXLauTIkXrqqac8ExIAAAAAAAAAAAD4j/B4g1CSnnzySfXo0UM7d+7Unj17FBsbK5vNpsDAQAUHB+uuu+6SYRiejgkAAAAAAAAAACyuxKBpWd52lok5AE/KFQ1CSTIMQ3fddZfuuusuT0cBAAAAAAAAAAAA/rN8PB0AAAAAAAAAAAAAgPt4/AnCPXv26L333tNff/2ly5cvZ2mf3bt3m5wKAAAAAAAAAAAA+G/yaINwz549at26tRITE2Wz2bK0D3MRAgAAAAAAAAAAADfOow3C8ePH6+LFi8qbN68GDRqke++9V3nz5vVkJAAAAAAAAAAAAOA/zaMNwk2bNskwDH3wwQd68sknPRkFAAAAAAAAAAAA8AoebRBeunRJktShQwdPxkAGoqOjFRMT47QsKSlJ/v7+HkoEAAAAAAAAAACAm+HRBmH58uX1zz//MK9gLhYWFqaQkBCX5UFBQR5IAwAAAAAAAAAAgJvl48k3f+qpp2Sz2TRv3jxPxkAG+vbtqy1btjj9q1ixoooWLerpaAAAAAAAAAAAALgBHn2CcODAgdqyZYteeeUV5c+fX0888YQn4yANQUFBLk8LBgQEyMfHo71lAHCbFb3LZHnbVl8dNzEJAAAAAAAAAOQMjzYI586dq44dO+rEiRN6/vnn9d577+nuu+9W2bJllSdP+tFGjRrlxpQAAAAAAAAAAADAf4dHG4R9+/Z1zD9os9l08OBBHTx4MN05CW02mwzDoEEIAAAAAAAAAAAA3CCPNgi7deuWbjMQAACYJ2jigGxtHz081KQkAAAAAAAAANzNow3Czz///KZf4/jx4ypZsqR8fX1zIBEAAAAAAAAAAADw3+bj6QA3q3bt2goPD/d0DAAAAAAAAAAAAMASLN8gtNlsno4AAAAAAAAAAAAAWIblG4QAAAAAAAAAAAAAso4GIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFLN8gLFeunPz8/DwdAwAAAAAAAAAAALCEPJ4OkJE//vhD69atU2pqqlq2bKnatWu7bLNz5073BwMAAAAAAAAAAAAsyuNPEO7du1ePPvqoypUrp5iYGMfyKVOmqGXLlho3bpzeeustNW/eXBMnTvRgUgAAAAAAAAAAAMD6PPoEYXh4uNq0aaNz587JMAzZbDZJUmRkpN58802lpqaqfv368vPz08aNG/XOO++ocePGatiwoSdjAwAAAAAAAAAAAJbl0ScI33//fZ07d0533nmn5s6dq8DAQEnSDz/8oOTkZDVv3lwrVqzQ4sWL9eyzz8pmsyksLMyTkQEAAAAAAAAAAABL82iDcP369TIMQ5MnT1arVq3k43M1zurVq2UYhp566inHti+88IIkacuWLR7Jmh6bzaapU6eqWbNmKlWqlMqVK6cOHTpoyZIlN/R6CQkJev3111WnTh0FBQWpSpUq6tWrl/bt25fDyQEAAAAAAAAAAOCNPNogPH36tCQpODjYsSwlJUXbt2+XJDVr1syxvHz58k775AY2m01PPfWUXnrpJf355586f/68zpw5o3Xr1umJJ57QhAkTsvV6MTExatasmSZNmqTDhw8rKSlJUVFR+umnn3T//fdr1apVWXqd5cuXq3DhwjfcpAQAAAAAAAAAAMB/l0cbhHnz5pUknTt3zrFs+/btunDhgipXrqygoCDH8vPnz0uS4ynD3CA0NFQLFixQQECAPvroIx0/flzh4eEaPHiwJGn8+PHasGFDll9v4MCBOnTokMqUKaP58+crKipK27ZtU8uWLZWYmKg+ffooPj4+09f55ptvbvhnAgAAAAAAAAAAwH+bR7ttd9xxhyRpwYIFjmVz5syRYRi6//77nbZdt26dJKl06dLuC5iBpKQkffTRR5Kkt99+W71791bhwoVVokQJvfXWW+rRo4dsNpsmTpyYpdfbvXu3Fi9eLF9fX33//fdq0aKF8uXLp2rVqmnOnDmqUqWK4uLiNG3atAxfZ9asWZo/f/7N/ngAAAAAAAAAAAD4j/Jog/Dxxx+XzWbT6NGjNXbsWA0fPlwzZ86UJHXr1k2SFBsbq+nTp2vIkCEyDMNp2FFP2rhxo06fPq1bb71VvXr1clk/dOhQSVcbm2fOnMn09X755RdJUsuWLZ2GXJWkgIAA9e/fX5JzM9Vu5syZ6tu3r2rUqOHYDgAAAAAAAAAAAEiLRxuEffr0UZMmTXTp0iVNnjxZYWFhSk1NVZcuXXTXXXdJkmbPnq2hQ4cqPj5ehQoV0pAhQzwZ2cE+dGizZs3k7+/vsr5q1aoqV66cUlJS9Pvvv2f6euvXr5cktWrVKs31LVu2lCTt2rVLZ8+edVr35Zdf6vvvv9fx48ez9TMAAAAAAAAAAADA++Tx5Jv7+vrq559/1tSpU7V27Vr5+/urSZMm6tOnj9N2fn5+atKkicaNG6fy5ct7KK2z8PBwSVLNmjXT3SY4OFgREREKDw9X27Zts/R61z89aFe+fHkVKVJEZ8+e1aFDh1S3bl3Hum+++UaXLl1y/P/OnTvr5MmTWf5ZAAAAAAAAAAAA4D082iCUrjb/+vXrp379+qW5vl+/fho0aJCbU2Xu2LFjkjKeE7FUqVKSpIiIiAxf6+LFi4qLi3PaJ73XO3v2rI4dO+bUIKxUqZLTdn5+fhmHBwAAAAAAAAAAgNfyeIMwM3ny5M6IFy5ckCQVLFgw3W3s6+zbZvZamb1egQIFJEnnz5/Pcs7sqF+/fpa2O3z4sCpUqKCoqChTclwv9dzFLG/rrkwAvEd8YkqWt83pY1DqxbOZb3SN7GTNzrFVyvxnMzMrv9esI+tVVsmalc92drJmJ6dE1qwi61VkzTqyZg3ngavImjVkzTqycmzNDrJmDVmvImvW5PSxFd7lypUr8vFx38yAbuu+vfnmmzp16pQMw1BoaKikq/ML3oju3bvnZLQbkpSUJElpzj9oZ3+SLzExMUuvldnr2ddl9noAAAAAAAAAAABAetzWIFywYIEOHjwoSY4GYb9+/WQYRrZfKzc0CAMCAiQ5N/eul5Um4rWvJUnJycnpbmefZ/Da7XPS1q1bs7Rd/fr15ePjoxIlSpiS43o+hfJneVt3ZQLgPW7N55vlbXP6GOSTv0i2tr/VlvWs2Tm2Spn/bGZm5feadWS9yipZs/LZzk7W7OSUyJpVZL2KrFlH1qzhPHAVWbOGrFlHVo6t2UHWrCHrVWTNmpw+tsK75MmTR6mpqe57P3e9kc1mk81mc1rWqFGjG2oQ5gZZGe7Tvs6+bWavJUnnzp1TYGDgTb0eAAAAAAAAAAAAkB63NQj/+OMPl2WLFy9219vnuLJly2rHjh06ceJEuttERkZKksqUKZPha+XPn19FixZVXFycIiMjVaFChTS3O3nypCSpdOnSNxYaAAAAAAAAAAAAXs99sx1m4NChQxo/frxGjBjhsu7+++/X0KFD9ddff3kgWfqqVKkiSdq7d2+62+zbt0+SVLVq1Uxfz77Nnj170lx/9OhRnTt3zum9AQAAAAAAAAAAgOxy2xOE6fn888/16quv6sqVK2k2vg4cOKAdO3Zo5syZCgkJ0XPPPeeBlK6aNGmi999/X2vXrlVycrLLPIPh4eGKiIiQr6+vGjVqlOnrNW7cWJs3b9bKlSv1/PPPu6xftWqVJKlWrVoqWrRozvwQWRAdHa2YmBinZUlJSZnOqwgAOSlo4oAsbxs9PNTEJPCE7Pz3l/gMAAAAAAAAAJnx6BOEGzZs0KhRo3T58mXVrl1bgwYNctnm888/V6tWrZSSkqKRI0dq8+bNHkjqqlGjRipRooTOnDmjmTNnuqyfPHmyJKl58+ZZauh17txZkrRy5UqXpxIvX76szz//XJLUpUuXm42eLWFhYWrQoIHTv3///VdxcXFuzQEAAAAAAAAAAICc4dEG4ZQpU2Sz2dSpUyetXr1aTz/9tMs2Dz30kObOnavevXsrNTVVU6ZM8UBSV/7+/ho6dKgkacyYMfrmm2907tw5RUVF6Y033tDMmTPl4+OjUaNGOe1Xr1491atXT2+88YbT8uDgYHXo0EEpKSnq1q2b1q1bp0uXLunvv/9W9+7ddeDAAQUFBenZZ591148oSerbt6+2bNni9K9ixYpufYoRAAAAAAAAAAAAOcejQ4xu3bpVhmFozJgx8vX1zXDbwYMH66uvvso1TxBKUr9+/bR582b98ssvGjBggAYMcB4Cbdy4cWrQoIHTsvDwcEnSqVOnXF5vypQpOnDggA4ePKgOHTo4rStQoIBmzJihwoUL5/BPkbGgoCAFBQU5LQsICJCPT66YvhIAAAAAAAAAAADZ5NEuz/nz5yVJFSpUyHTbUqVKSZISEhLMjJQthmFo5syZmjRpku666y4VKFBAt9xyi5o1a6a5c+dq8ODB2Xq9wMBArV27VkOHDlWlSpUUEBCg4sWL69FHH9WaNWvUpEkTk34SAAAAAAAAAAAAeAuPPkFYvHhxnThxQocPH9Ydd9yR4bb2J+8CAwPdES3LDMNQnz591KdPnyxtn1mDs1ChQho3bpzGjRt3w5mun8MQAAAAAAAAAAAAsPPoE4TNmzeXzWbTG2+8odTU1HS3s9lseuutt2QYBk/RuVl0dLT279/v9C8pKUkpKSmejgYAAAAAAAAAAIAb4NEG4bBhw5Q/f34tXbpUrVu31pIlS5yesEtMTNTq1avVvn17LVmyRHny5NFLL73kwcTeJywsTA0aNHD69++//youLs7T0QAAAAAAAAAAAHADPDrEaMWKFTVr1iz17NlT27ZtU7du3SRJBQsWlI+Pj86dOyebzSabzaaAgAB9/vnnql69uicje52+ffuqc+fOTsu6du0qf39/DyUCAAAAAAAAAADAzfBog1CSHnjgAW3ZskXvv/++fvnlF8XGxurcuXOO9QULFlTbtm01YsQIVa1a1YNJvVNQUJCCgoKclgUEBMjHx6MPnwIAAAAAAAAAAOAGebxBKEmlSpXShx9+qA8//FARERGKjo5WSkqKihYtqkqVKtGMAgAAAAAAAAAAAHJIrmgQXqtcuXIqV66cp2MAAAAAAAAAAAAA/0k8mgcAAAAAAAAAAAB4kVz3BCFyl+joaMXExDgtS0pKkr+/v4cSAQAAAAAAAAAA4GbQIESGwsLCFBIS4rI8KCjIA2kAAAAAAAAAAABws2gQIkN9+/ZV586dnZZ17dqVJwgBWFqJQdOyvO0sE3MAAAAAAAAAgCfQIESGgoKCXJ4WDAgIkI8P01cCAAAAAAAAAABYEV0eAAAAAAAAAAAAwIvQIAQAAAAAAAAAAAC8CA1CAAAAAAAAAAAAwIvQIAQAAAAAAAAAAAC8SB5PB0DuFh0drZiYGKdlSUlJ8vf391AiAAAAAAAAAAAA3AwahMhQWFiYQkJCXJYHBQV5IA0AAAAAAAAAAABuFg1CZKhv377q3Lmz07KuXbvyBCEAAAAAAAAAAIBF0SBEhoKCglyeFgwICJCPD9NXAgAAAAAAAAAAWBFdHgAAAAAAAAAAAMCL0CAEAAAAAAAAAAAAvAgNQgAAAAAAAAAAAMCL0CAEAAAAAAAAAAAAvAgNQgAAAAAAAAAAAMCL5PF0AORu0dHRiomJcVqWlJQkf39/DyUCAAAAAAAAAADAzaBBiAyFhYUpJCTEZXlQUJAH0gAAAAAAAAAAAOBm0SBEhvr27avOnTs7LevatStPEAIAAAAAAAAAAFgUDUJkKCgoyOVpwYCAAPn4MH0lAAAAAAAAAACAFdHlAQAAAAAAAAAAALwIDUIAAAAAAAAAAADAizDEKOClgiYOyPK20cNDTUySOStltRJ+rwAAAAAAAADgnXiCEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAieTwdALlbdHS0YmJinJYlJSXJ39/fQ4kA/Bes6F0meztUf9icIAAAAAAAAADghWgQIkNhYWEKCQlxWR4UFOSBNAAAAAAAAAAAALhZNAiRob59+6pz585Oy7p27coThAAAAAAAAAAAABZFgxAZCgoKcnlaMCAgQD4+TF8JAAAAAAAAAABgRXR5AAAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC+Sx9MBAAA5Y0XvMtnbofrD5gQBAAAAAAAAAORqNAgBADmixKBpWd52lok5AAAAAAAAAAAZo0GIDEVHRysmJsZpWVJSkvz9/T2UCAAAAAAAAAAAADeDBiEyFBYWppCQEJflQUFBHkgDAAAAAAAAAACAm0WDEBnq27evOnfu7LSsa9euPEEIAAAAAAAAAABgUTQIkaGgoCCXpwUDAgLk4+PjoUQAAAAAAAAAAAC4GXR5AAAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC/CHIQAkIuVGDQty9vOMjEHAAAAAAAAAOC/gycIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwInk8HQBwtxKDpmV526gpfUxMAgAAAAAAAAAA4H48QQgAAAAAAAAAAAB4ERqEAAAAAAAAAAAAgBdhiFHgP2JF7zLZ26H6w+YEyQIrZQUAAAAAAAAA4L+GBiEyFB0drZiYGKdlSUlJ8vf391AiAAAAAAAAAAAA3AwahMhQWFiYQkJCXJYHBQV5IA0AAAAAAAAAAABuFg1CZKhv377q3Lmz07KuXbvyBCEAAAAAAAAAAIBF0SBEhoKCglyeFgwICJCPj89NvW625qBj/jkAAAAAAAAAAIAcc3NdHgAAAAAAAAAAAACWQoMQAAAAAAAAAAAA8CI0CAEAAAAAAAAAAAAvQoMQAAAAAAAAAAAA8CJ5PB0A/w0lBk3L1vazTMqR01b0LpOt7Vt9ddykJAAAAAAAAAAAADmDJwgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL0KDEAAAAAAAAAAAAPAiNAgBAAAAAAAAAAAAL5LH0wEAIDdb0btMtrZv9dVxk5IAAAAAAAAAAJAzeIIQAAAAAAAAAAAA8CI0CAEAAAAAAAAAAAAvQoMQAAAAAAAAAAAA8CI0CAEAAAAAAAAAAAAvQoMQAAAAAAAAAAAA8CI0CAEAAAAAAAAAAAAvQoMQAAAAAAAAAAAA8CI0CP+fzWbT1KlT1axZM5UqVUrlypVThw4dtGTJkht6vYSEBL3++uuqU6eOgoKCVKVKFfXq1Uv79u3LcL9Tp07ppZdeUs2aNRUUFKTq1atr0KBBioiIuKEcAAAAAAAAAAAAwLVoEOpqc/Cpp57SSy+9pD///FPnz5/XmTNntG7dOj3xxBOaMGFCtl4vJiZGzZo106RJk3T48GElJSUpKipKP/30k+6//36tWrUqzf3Cw8PVqFEjTZ06VREREUpKStKJEyc0c+ZMNWnSRHv27MnS+0+dOlWFCxfWX3/9la3cAAAAAAAAAAAA+O+jQSgpNDRUCxYsUEBAgD766CMdP35c4eHhGjx4sCRp/Pjx2rBhQ5Zfb+DAgTp06JDKlCmj+fPnKyoqStu2bVPLli2VmJioPn36KD4+3mkfm82mXr16KTo6WjVr1tTKlSsVFRWlNWvWqG7duoqPj9czzzyjK1euZPr+33zzTfZ+AQAAAAAAAAAAAPAaXt8gTEpK0kcffSRJevvtt9W7d28VLlxYJUqU0FtvvaUePXrIZrNp4sSJWXq93bt3a/HixfL19dX333+vFi1aKF++fKpWrZrmzJmjKlWqKC4uTtOmTXPab/Hixdq9e7cKFSqkn376SfXr11e+fPlUt25d/fTTTypatKgOHjyoefPmpfveKSkpmjBhgv78888b/n0AAAAAAAAAAADgvy2PpwN42saNG3X69Gndeuut6tWrl8v6oUOH6ttvv9W6det05swZ3XLLLRm+3i+//CJJatmypYKDg53WBQQEqH///ho6dKgWLFigYcOGOdbZG39du3ZVyZIlnfYLDAzUM888o0mTJmnBggV6/PHHndZ/9NFH+vPPP7VhwwZFR0dn9UeHBZQYNC3zjf7fLBNzZIWVsgIAAAAAAAAA4M28/glC+9ChzZo1k7+/v8v6qlWrqly5ckpJSdHvv/+e6eutX79ektSqVas017ds2VKStGvXLp09e9YlR2b72V//Wh988IF+/vlnmoMAAAAAAAAAAADIlNc3CMPDwyVJNWvWTHcb+5OA9m2z8nrXPz1oV758eRUpUkQ2m02HDh2SJJ0/f14nT57McD/78vj4eMXGxjqtW7lypTZv3uz4BwAAAAAAAAAAAKTH64cYPXbsmCSpdOnS6W5TqlQpSVJERESGr3Xx4kXFxcU57ZPe6509e1bHjh1T3bp1dfz4cUmSj4+PbrvttjT3ueWWW1SgQAFduHBBERERCgwMdKyrVq1ahrkAAAAAAAAAAAAAO69vEF64cEGSVLBgwXS3sa+zb5vZa2X2egUKFJB09cnBa/83f/788vX1zXC/CxcuZJrjRtWvXz9L2x0+fFgVKlRQVFSUY1nqxbMZ7OEqPjEly9umnruY5W2vzZTu62Uja3ZyZvX9s8PMrFb6veZ01uzgM3DVf+0zYFZWT/73l8w7tkqZ/2xk/f/XJmuWkZVja3aQNWvIehVZs84qWf+r5wGJrFlF1qwjK8fW7CBr1pD1KrJmTU4fW+Fdrly5Ih8f9w386fVDjCYlJUlSmvMP2vn5+UmSEhMTs/Ramb2efZ399ZKTk53eJ7P9Ll7M3kEGAAAAAAAAAAAAsPP6JwgDAgIkOTf3rpeVJuK1ryX9r+mXlkuXLjltb3/djPZJa7+ctnXr1ixtV79+ffn4+KhEiRKOZT75i2TrvW61pf+k5PV8CuXP8rbXZkr39bKRNTs5s/r+2WFmViv9XnM6a3bcmo/PgPTf+wyYldWT//0l846tUuY/G1n//7XJmmVk5diaHWTNGrJeRdass0rW/+p5QCJrVpE168jKsTU7yJo1ZL2KrFmT08dWeJc8efIoNTXVbe/n9U8QXj/cZ1rs6+zbZvZaknTu3Lksv559ONLExERduXIl3f3sQ4tmlgMAAAAAAAAAAABIj9c3CMuWLStJOnHiRLrbREZGSpLKlCmT4Wvlz59fRYsWddonLSdPnpQklS5d2ul1U1NTderUqTT3iYuLcwxJmlkOAAAAAAAAAAAAID1e3yCsUqWKJGnv3r3pbrNv3z5JUtWqVTN9Pfs2e/bsSXP90aNHHU8X2t+7YMGCKlWqVIb72TMULlxYt912W6Y5AAAAAAAAAAAAgLR4fYOwSZMmkqS1a9emOQdgeHi4IiIi5Ovrq0aNGmX6eo0bN5YkrVy5Ms31q1atkiTVqlXL8bRhdvZr2rRpphlyUnR0tPbv3+/0LykpSSkpKW7NAQAAAAAAAAAAgJyRx9MBPK1Ro0YqUaKEoqKiNHPmTPXt29dp/eTJkyVJzZs3d2ropadz5856//33tXLlSu3du1c1a9Z0rLt8+bI+//xzSVKXLl2c9uvSpYt++OEHff/99xoxYoTT5KTx8fH6+uuv09zPbGFhYQoJCXFZHhQU5NYcQE4qMWhalredZWIOAAAAAAAAAAA8weufIPT399fQoUMlSWPGjNE333yjc+fOKSoqSm+88YZmzpwpHx8fjRo1ymm/evXqqV69enrjjTeclgcHB6tDhw5KSUlRt27dtG7dOl26dEl///23unfvrgMHDigoKEjPPvus035t27ZV7dq1lZCQoEcffVQ7duzQpUuX9Oeff+qRRx5RTEyMqlevrs6dO5v6+7he3759tWXLFqd/FStWzFKzFAAAAAAAAAAAALmP1z9BKEn9+vXT5s2b9csvv2jAgAEaMGCA0/px48apQYMGTsvCw8MlSadOnXJ5vSlTpujAgQM6ePCgOnTo4LSuQIECmjFjhgoXLuy03DAMTZ8+XW3atNGuXbvUvHlzp/WBgYH6+uuv5evre6M/5g0JCgpyeVowICBAPj5e31sGAAAAAAAAAACwJLo8utqcmzlzpiZNmqS77rpLBQoU0C233KJmzZpp7ty5Gjx4cLZeLzAwUGvXrtXQoUNVqVIlBQQEqHjx4nr00Ue1Zs0ax7yH16tcubI2btyoZ599VmXLllVAQIBKly6tnj17auPGjapWrVpO/LgAAAAAAAAAAADwYjxB+P8Mw1CfPn3Up0+fLG2fkJCQ4fpChQpp3LhxGjduXLZylChRQh9++GG29rleZtkAAAAAAAAAAADgvWgQIkPR0dGKiYlxWpaUlCR/f38PJQIAAAAAAAAAAMDNoEGIDIWFhSkkJMRl+fXzEgIAAAAAAAAAAMAaaBAiQ3379lXnzp2dlnXt2pUnCAEAAAAAAAAAACyKBiEyFBQU5PK0YEBAgHx8fDyUCAAAAAAAAAAAADeDLg8AAAAAAAAAAADgRWgQAgAAAAAAAAAAAF6EBiEAAAAAAAAAAADgRZiDEBmKjo5WTEyM07KkpCT5+/t7KBEAAAAAAAAAAABuBg1CZCgsLEwhISEuy4OCgjyQBgAAAAAAAAAAADeLBiEy1LdvX3Xu3NlpWdeuXXmCEAAAAAAAAAAAwKJoECJDQUFBLk8LBgQEyMeH6SsBAAAAAAAAAACsiC4PAAAAAAAAAAAA4EVoEAIAAAAAAAAAAABehAYhAAAAAAAAAAAA4EWYgxAZio6OVkxMjNOypKQk+fv7eygRAAAAAAAAAAAAboaRkJBg83QI5F7jx49XSEiIy3JfX19Vq1bN8f//PnUmW69bJvV0lrc9HlAoy9tWCyyZ6TbZyZqdnJJUoFTVbG2fGTOzWun3aqWsfAay5r+a1ZP//SXzjq1S5r9Xsl5F1qwjK8fW7CBr1pD1KrJmnVWy/lfPAxJZs4qsWUdWjq3ZQdasIetVZM2anD62wrscOnRIfn5+ioyMdMv70SBEhtJ6grBt27ZKSkpS2bJlJUkpKSmKj4/XrbfeKl9f3zRfJ7NtDh8+LEmqVKlSulkye42cyEFWc7Jm5TXI6pms7vosktWcHGQlqzvOA2TNvedXsube8ytZyeptdYuVsnpbLWClrN5WC5A199YCZM2951ey5t7zK1nJ6m11i1lZjx8/rvz58+vgwYNpbp/TaBDipu3fv18NGjTQli1bVL169Rvapn79+pKkrVu33vD75EQOspqTNSuvQVbPZHXXZ5Gs5uQgK1ndcR4ga+49v5I1955fyUpWb6tbrJTV22oBK2X1tlqArLm3FiBr7j2/kjX3nl/JSlZvq1vcldVsPm5/RwAAAAAAAAAAAAAeQ4MQAAAAAAAAAAAA8CI0CAEAAAAAAAAAAAAvQoMQAAAAAAAAAAAA8CI0CHHTihUrplGjRqlYsWI3tc3Nvk9O5SBrzufIiZxkNSeruz6LZDUnB1nJSlbrZvW2WsBKWb2tFiCrOVm9rW6xUtbccrwiK1nJak5Wb6tbrJTV22oBK2X1tlqArJ7LQVZz3udmGAkJCTaPvDNwjfr160uStm7d6uEkmSOrOchqDrKag6zmIGvOs0pOiaxmIas5yGoOspqDrOYga86zSk6JrGYhqznIag6ymoOs5iCrOayUNT08QQgAAAAAAAAAAAB4ERqEAAAAAAAAAAAAgBehQQgAAAAAAAAAAAB4EeYgBAAAAAAAAAAAALwITxACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBACAAAAAAAAAAAAXoQGIQAAAAAAAAAAAOBFaBDC40JCQjRhwgRPx8gSsprDSllnz56t2bNnezpGlmzcuFEbN270dIwsIas5jh07pmPHjnk6RpYUKVJEt956q6djZAlZc15wcLBq1arl6RhZ0qFDB3Xs2NHTMbKErObo37+/BgwY4OkYWWKlGous5qB2NQdZzUHtmvOsklOyVlZqV3OQ1RzUruYgqzmsVLta6VyQESMhIcHm6RDwbkWKFJFhGDpz5oyno2SKrOawWlYfHx/Fx8d7OkqmyGoOsprDascBsuYsq+SUyGoWspqDrOawWlYr1QJkzXlkNYdVjgNWySmR1SxkNQdZzUFWc1gtK7WAe/EEIQBkk81mnfsqyGoOsgIAAKuwUi1AVnOQFQAAWAW1gHvRIAQAAAAAAAAAAAC8SB5PBwAAAN4lo3lwNm3a5HK3WKNGjcyOlC6y5ryM5hY6fvy4S86yZcuaHQkAACBdVqmxrJJTslZWalcAwH/5XECDEG7VoUOHLK8zDEMLFy40O1K6yGoOK2Xt379/ltcZhqHQ0FCzI6UrJCQk3XUTJkxwOlEZhqGRI0e6I1aayGqOjCZxnjNnjkux0r17d7Mjpatdu3YyDMNluc1mU7t27VyWe3I8d7LmvJo1a6abs2bNmk7LDMPw6NwD9jkFrmez2XTLLbc4LSNr1lkpa0aTzqe1bvfu3WbGyZCVaiyymoPa1RxkNQe1a86zSk7JWlmpXc1BVnNQu5qDrOawUu1qpXNBdhkJCQkM6gq3KVKkSJa39fQkn2Q1B1nNQVZzWC3r9cWK/cLKtcttNpvHs44fP94l04QJE9K9UDV69Gh3xnNC1pz3wgsvuHxWZ8+eLcMw1K1bN5ftP/vsM3dFc5HWxasNGzbIMIw072RftGiRu6K5IKs50voiGBERIcMw0rwrdM+ePe6K5sJq56ysImvWkdUcZDUHtWvOs0pOyVpZqV3NQVZzULuag6zmsFJWK50LsosGITzO/sXAk3/kWUVWc+TWrBEREU7/32azqVatWjIMI827rMqVK+euaC42bNjg9P9tNps6dOggwzD066+/umzfuHFjd0VzQVZzfPvtty7L+vfvn+5dVj169HBHrCzLrceBtJA151klp0RWs5DVHGQ1R27NSu1qDrKag9rVPaySUyKrWchqDrKag6zmyK1ZrVS7piW3/l6ziwYhPM5Kf0xkNQdZzUFWc5DVHGQ1h1WyWiWnRFazkNUcZDUHWc1BVnOQ1RxWyWqVnBJZzUJWc5DVHGQ1B1nNYaWsGfHxdAAAAAAAAAAAAAAA7kODEAAAAAAAAAAAAPAieTwdAGjUqJHLJJ+5FVnNYaWsZcuWlY8P91YAOc2TE7lnF1lz3qeffurpCFk2cuRIy5yzyGqObt26WSarlWosspqD2hUwh1VqLKvklKyVldrVHGQ1B7WrOchqDivVrlY6F2SEOQgBAPiPsk/4nNsmcgYAAACuR+0KAADgXjQIAQAAAAAAAAAAAC9ijec18Z+2ceNGbdy40dMxsoSs5rBS1mPHjunYsWOejgH853To0EEdO3b0dIwsIWvO69+/vwYMGODpGFkSEhKikJAQT8fIErKaY/bs2Zo9e7anY2SJlWosspqD2hUwh1VqLKvklKyVldrVHGQ1B7WrOchqDivVrlY6F2SEJwjhcUWKFJGPj4/i4+M9HSVTZDUHWc1BVnNYKWtwcLAMw9Du3bs9HSVTRYoUkWEYOnPmjKejZIqsOc8qOSWymsVqWa1yHiCrOchqDrKaw0pZqV1znlVySmQ1C1nNYbWsVjkPkNUcZDWHlY4DGcnj6QCAJNls1ulTk9UcZDUHWc1hlawRERGWmYgaAKzEKucBiaxmIas5yGoOq2SldgUAc1jlPCCR1SxkRXoYYhQAAAAAAAAAAADwIjQIAQAAAAAAAAAAAC9CgxAAAAAAAAAAAADwIsxBCI9r1KiRZeYZIKs5rJS1bNmy8vHh3gogpy1atMjTEbKMrDnv008/9XSELBs5cqRlzllkNUe3bt0sk9VKNRZZzUHtCpjDKjWWVXJK1spK7WoOspqD2tUcZDWHlWpXK50LMmIkJCQw6yNyXHx8vG699VZPx8gSsprDSlltNptlTpRAdkREREiSypUr55H3Hz16tNq1a6f77rtPvr6+HsmQVWTNeZ999pnatWun8uXLezpKphYvXqwWLVooX758no6SKbKaY+/evapZs6anY2SJlWosspqD2hX/VdSuWWOVnJK1slK7moOs5qB2NQdZzWGl2tVK54KcQoMQpihatKgaNGig9u3bq02bNqpcubKnI6WLrOawUtYKFSqoTZs2ateunR544AEVKFDA05HS1aRJE7Vt21Zt27bVXXfd5ek4GSKrOXr06KF27drpwQcfVLFixTwdJ0ONGzfWnj17VKRIEbVq1Urt2rVTq1atVLhwYU9Hc0HWnFexYkXFx8frjjvuULt27dS2bVvdc889no6VpqJFi8rf319NmzZV+/bt9eCDD+q2227zdKw0kdUcRYoUUdmyZdWmTRu1b99ejRs3lp+fn6djpclKNRZZzUHtag6ymoPaNedZJadkrazUruYgqzmoXc1BVnNYqXa10rkgp9AghCkWLVqkJUuWaNmyZYqOjtbtt9+udu3aqX379mrQoEGuumuArOawUtZPP/1US5cu1aZNm+Tj46NGjRqpffv2atu2rUqXLu3peE5GjRqlpUuX6t9//1XJkiUdJ9jmzZvL39/f0/GckNUc3bt315o1a5SYmKi7775bbdu2Vbt27XTHHXd4OlqaTpw4oUWLFmnp0qXasGGDUlNTdd9996ldu3Zq06aNKlSo4OmIDmTNWampqdq8ebOWLFmiJUuWKDw8XMWLF9eDDz6o9u3bq3nz5rnm7tz4+HgtXbpUS5cu1apVq3ThwgXVrl1b7dq1U7t27XLV3blkNceePXu0ePFiLVmyRDt37lTBggX1wAMPqF27dmrdunWuujvXSjUWWc1B7WoOspqD2tUcVskpWScrtas5yGoOaldzkNUcVqpdrXQuyCk0CGG6rVu3aunSpVq8eLH279+vokWLqnXr1mrfvn2uu2uArOawStaEhAQtX75cS5Ys0YoVK5SQkKDg4GDHF+7cdHfu/v37HSer7du3K1++fGrRokWuvDuXrDkvKSlJv/32m5YtW6alS5fq5MmTKl++vOOLS24dwufChQtasWKFlixZouXLlzvdldWuXTvdfffdno7oQNacd+jQIceXmC1btjjdndumTRuVKFHC0xElSZcvX9a6deu0ZMkSLV26VMePH1eZMmUcd+c2adJEefLkjmm8yWqOqKgoxwWXtWvX6sqVK6pfv36uvDvXKjWWRFYzULuag6w5j9rVXFbJKVkrK7VrziOrOahdzUHWnGel2tXOKueCm0GDEG519OhRx51j9rsGGjdu7HhkNzfdNUBWc1gla0pKijZs2KClS5dqyZIljrtz7UP55Ka7c2NiYhxF62+//aZLly6pXr16jt9pbro7l6zm2LFjhxYvXqxly5Zp9+7djiF82rdvr5YtW+bKIXyuvStr8eLFOnjwYK69K4usOY+7c81B1pyXmJio1atXO92dW7lyZbVt2zbX3Z1rlRpLIqsZqF3NQVZzULuSU7JWVmpXc5A151G7moOsOc9Ktaudlc4F2UGDEB6TkJDguIPw2rsGcuNcCmQ1h5Wy7t+/X4sXL9bSpUstcXeu/YR16tQpx9257du3V8OGDXPN3blkNYd9CJ8lS5Zow4YNstlsjiF82rZtm2snWj548KDjC1duvyuLrDnLSnfnnjp1yvGkhv3u3AYNGjiGyMpNd+eSNefZbDZt3bpVy5Ytc9ydGxgYqNatW+e6+TSsVGOR1RzUrjmPrOagdjWXVXJK1slK7WoOsuY8aldzkNUcVqld7ax0LsgMDULkCva7Buwn2CNHjjjuGnj22Wd15513ejqiA1nNYaWs9rtzlyxZojVr1jjuzm3fvr0effRRlSlTxtMRHex35y5dutRpcvj27durVatWKlSokKcjOpA151lpCJ9rxcXFOYpY+11Z7777rl544QVPR3NB1py3e/duxzF2586dKlSokN577z1169bN09GcJCYmatWqVVq6dKnT3blvvfWW2rZt6+l4TshqjqNHj+rXX3/VsmXLnO7OHTZsmO677z5Px3OwUo1lxaz2eiA3Z6V2NQdZcx61q7msklOyVlZq15xHVnNQu+Y8sprDSrWrnVXOBWmhQYhc6cCBA467CB988EENHz7c05HSZaWs9rsxyJpz7Hfn2odv6Nmzp0aNGuXpWGk6fvy443e6YcMGvfzyy7k26/V3EufmrFb5vV4/hM+hQ4c0ZsyYXPu3ZWe/KysgIECNGzf2dJwMkTXnnTx5UkuXLlWJEiXUrl07T8dJl/3u3KVLl6pKlSrq3r27pyOli6zmsN+du2TJEt1zzz3q16+fpyOlyyo1lmStrFb5TkDtag4rZbVKnU3tai6r5JSslZXaNeeR1RxWql2tUmNJ1qpdrZLVSrWrnVXOBXY0CJHr2Wy2XDM+dmbIemNSUlIUFxcnPz8/3XLLLS7rc1PWzJw9e1ZFihTxdIxMnT9/XnFxcSpXrpyno2SKrOY4ePCgEhMTFRwc7OkokqTo6GitXLlSUVFRKlasmJo2beqx32NqaqqOHj2qihUruqzbunWr1q5dq8jISPn7+6ty5cpq06aNypYt64GkV0VFRen333/XhQsXVL58ed1zzz0KCAjIcJ/FixdLkkeK1bi4OB07dkwXLlzQxYsXFRAQoAIFCqhMmTIqXry42/PciOPHj+vUqVMqVqyYKlSo4Ok4io2N1fnz51WmTJksDRmXkJAgSblujqfExESdP39egYGB8vHx8XQcF0lJSZn+bVmNlWqs3Jg1vWNpbsyaHmrXnEdWc3iidr1y5Yr27t2r8PBwxcbG6sKFC/L19VWBAgVUrFgxValSRVWrVs11cyRdKzfV2Jk5ceKE9u3bp/Pnz6t06dKqV69erhie7b9Qu0rS6NGjZRiGxo8f7/b3DgkJUb58+dS3b1/lz5/f7e9vFmpX98tNNZbVrmVeuXIl3WNqbsuaEavUrlZCgxC4xuHDhzVlyhRt2rTJcaG1ffv26tWrV4aTYzdp0kSGYWjdunVuzfrXX3/JZrOpRo0auv322x3r/v77b4WGhmrPnj06f/68SpUqpZYtW6pXr14qWLCg2zJK0pkzZzRnzhxFRkbqrbfeclq3adMmTZw4UZs2bVJSUpIkKTAwUB06dNBLL73ksfkm9u/fr/Xr1ys8PDzdLwJVqlRRs2bNPP4Ifnx8vAzDSLMYWbRokRYvXuy4iN28eXM99thjHvmSlZKSovnz52vjxo1Of1u1atXKcD9PfInZu3ev/vnnH3Xp0sVp+ZkzZ/TVV1+5NIc6dOigRx55xKNfCPbv36/w8HBFRETowoULSkxMlL+/vwoWLKjSpUuratWqHm0Ebtu2TWFhYdq7d68Mw1CtWrU0dOhQVa1aVZI0ZcoUvf32247jgCQZhqEnn3xS77//vtu+1Fy+fFkffPCBwsLCVLp0aadj+unTp/Xss8+meZz39fVVnz599M4778jPz88tWaWrX/iGDx+uWbNmKTU11bE8KChIY8aMUc+ePdPdt0iRIvLx8VF8fLzpOVNTUzVv3jwtWLBA69evz/A9CxcurKZNm6pLly7q3Lmz27+kXLhwQfPmzdOePXscn9VHHnlEefPmlSRt3rxZw4cP1549exz7lC9fXq+88oqeeOIJt2aVpB9++EETJ05UeHi4pKufxQcffFCjR4/O8G/enf/9patf4ubPn699+/bJZrPpzjvv1GOPPea4QDR79mxNnDhR//77ryQpICBAzZo104gRIzwynJz96ZoNGzY41QI229WvTfny5XMcW5s2baqHHnpIpUqVcntOyTr1oNWyZpW7/5bSQ+1qDitltZrcXrv+888/mjhxopYuXapz585luG3+/PnVvHlz9enTRw888ICbEl5llRpbkjZu3KgZM2Y4zgN33nmnBg4cqNq1a+vKlSt68cUX9d133znVtEWKFNHw4cM1cOBAt+WUrFW7ZkeRIkVkGIbOnDnjsfeuUqWKZs6cqRo1arg9Q3ZQu8Iq1zLt3wOrVKnisu706dP65JNPtHTpUh0+fFhXrlxRoUKFdNddd+nxxx9X165dPVa3WKl2zUiHDh1kGIYWLlzo6Sg3hQYh8P8WL16sPn36KDEx0XESla4W0JUqVdK8efPSfUrAnYXWiRMn9Pzzz2vDhg1Oyzt16qQvvvhCO3fuVJcuXZyKAenqz1GqVCn98MMPqlmzpuk5JWn58uV6/vnnFR8fr+DgYK1fv96xLjQ0VK+++qpsNptTTnvWQoUK6euvv1aLFi3cklWSvvvuO73//vs6ePCgJLnkupa98K9WrZpGjx6tTp06uSOipKu5Jk+erC+++EKRkZGSpLJly+rVV1/VE088oUuXLqlnz55aunSpy2egatWq+v7779N8Msoshw8fVteuXfXPP/848tt/f4888og+/fTTdL+cuvNv69ixY+rXr582bNjg8nn9/fff9eSTTyo2NjbNz2vt2rU1a9Ystz5FdvjwYU2ePFkLFy5UbGxsptsXLVpUnTp10pAhQ9x613B6f+uFCxfWzz//rD179mjIkCGSpFq1aqlMmTI6duyYo0HTqlUrzZ071/ScV65c0SOPPKK1a9fKZrOpXr16Wr16taSrd9fff//9+ueff2Sz2XT33XerWrVqyps3r3bs2KE///xThmGobdu2mjNnjulZpasXLjp37uzIW65cOQUFBengwYM6e/asDMPQ0KFD9frrr6e5v7v+tvbt26dnnnlGBw8edPrvX6BAARUoUED+/v66dOmS4+KgnWEYqlGjhmbOnJnmlx0zbN68WU899ZSio6OdlteoUUO//PKLDh48qM6dO+vSpUuO89S5c+ccx7RRo0a5daiTN998Ux9++GGa56p8+fJp+vTp6c574s5j66pVq9SnTx+X96pQoYIWLlyoNWvWaNCgQWn+HH5+fvrkk0/UtWtX03NKVxvEI0eO1HfffacrV65kWAfYGYYhPz8/Pf3003rnnXcczWSzWaketFLW7PLkxVaJ2tXbs1qNVWrXb7/9VoMHD3acB2677TYFBATo+PHjSklJcdT+ly9f1rFjxxxP5RuGoebNm2vatGkKDAw0PadVamxJmjBhgt59911JzsepfPny6aefftKiRYsUGhoqSbr11ltVrFgxHT16VMnJyTIMQ3369NEHH3zglqxWql2zKzc0CPPmzavU1FSNGDFCQ4cOzdLIF+5G7QorXctM72a19evX6+mnn1Z8fHyanwv7uezbb79163x+Vqlds8rT3wVyCg1CQFeHK2ncuLFjyJJ+/fqpePHi2rlzp7744gtFR0erdOnS2rRpU5p3kLrrgHDmzBk1bdpUERERstlsKl68uAoWLKgjR47IZrOpT58+2rx5s/bu3at69erp8ccfV1BQkMLDwzV9+nSdOnVKpUqV0saNG1W0aFFTs+7evVstW7ZUUlKSKlSooIEDB6pv376SrjZb2rZtK5vNpsaNG2vo0KGqVq2a8uXLp+3bt2vixInavn27ChUqpE2bNrnlC+GgQYP0zTffyGazKW/evLr77rsVHBys0qVLO30ROH/+vCIjI7Vv3z5t377dcaG4b9++mjhxouk5JemZZ57R/Pnz0yxGpkyZot27d+vLL79UYGCgnnjiCceXwe+//15xcXG6/fbbtX79ehUoUMD0rGfPnlWTJk109OhR5c+fX506dXL8ba1Zs0aGYahJkyaaP39+mk/guetvKzo6Wk2bNtXJkyfl4+Ojbt26Ob6kHj16VI0bN1ZCQoJuueUW9erVS1WrVlW+fPn0xx9/6Ouvv9bZs2dVpUoVrV271i2/19mzZ2vo0KFKSkqSzWZTQECAqlatqlKlSjk+r0lJSTp37pxOnjyp8PBwxxfsfPnyKTQ01OUJSTNc+7feunVrdezYUb6+vlq4cKGWLFmiUqVK6fz580pNTdXs2bPVrFkzx76rV69Wjx49lJiYqKlTp+rRRx81NetHH32k119/Xfnz59c777yj7t27O74shYSE6N1331VQUJCmT5+uJk2aOO27ZMkS9e7dW4mJifr888/d8oVw5syZevHFFxUQEKDPPvtMjzzyiKSrw9xMmDBBkyZNkmEY+vbbb9W+fXuX/d3xt3Xs2DE1adJE8fHxKlq0qJ555hm1bNlSwcHBaQ4JEh8fr3379mnlypX65ptvFBMTo6CgIG3YsEG33XabaTkl57/z2267TU2bNpWvr6/Wrl2rkydP6t5771VUVJT+/fdfx53sRYoU0ZkzZzR58mR9+OGHMgxDy5YtU/369U3NKklr167VQw89JMMw1KtXLw0dOtRxbH3zzTe1ceNG5c2bV2vXrtUdd9zhsr+7jq3h4eFq2rSpLl68qMDAQDVr1kyFChXS1q1btX//fjVr1kz79+9XTEyMBgwYoG7dujnqlo8++kjLly9XQECANmzY4HgawiyXLl1S69attXv3bseNAC1btlStWrVUqlQpFSxYUH5+fk7H1r1792rVqlXatm2bDMNQvXr1tGTJEtOHmrNSPWilrNLVGis7fvnlFxmGoYcfftixzDAMzZgxI4eTuaJ2JauVWKV23b59u1q3bq2UlBR16dJFb7zxhuNJkLi4OE2YMEGff/652rZtq++++07S1XPd/Pnz9dlnnykmJkY1a9bUqlWrTL3obqUa+7fffnNc1G3WrJk6deqkggULatOmTZoxY4bKly+vkydPKl++fPriiy/Upk0bSVdv3gsNDdWbb76plJQUzZs3T/fff7+pWa1Uu0pSpUqVsrV9bGysDMNwOp8ahqFDhw7ldDQX9tpz27ZteuGFF7R9+3bdeeedGj9+vJo3b276+2cVtSusdi0zre91ERERuu+++3Tu3DmVKFFC/fv3V6NGjRQYGKiEhARt3rxZn376qY4ePaqqVatq3bp1GY6al1OsVLtmFQ1C4D9k0KBB+vrrr1WnTh3HCd3u+PHjateunSIiItSlSxd99dVXLvu764Dw9ttva+LEiSpZsqS++uor3XfffZKkyMhIPfHEE44hz+6//379+OOPTg2Xs2fP6sEHH9SBAwc0YsQIvfLKK6ZmffLJJ7Vw4UI1b95c3333ndPJplu3blq8eLEee+wxTZ061WXflJQUde7cWevWrVOvXr00adIkU7N+++236t+/v3x9fTVixAj169cvS+NZJyQk6IsvvlBISIhSUlIUFhamxx57zC1Z8+bNqzFjxqhDhw6OL4Nvv/22UlNTdfnyZZUtW1arVq1SUFCQY9+oqCjdf//9OnHihMaNG6fBgwebmlWS3nnnHb333nsqUaKEli1b5nRH9cqVK/X000/r4sWLGjNmTJoTIrvrb+vll1/W1KlTVaFCBX3//fdOF9RffPFFzZw5U3Xq1NEvv/yiW2+91Wnfa48R6f0cOWnz5s1q166dUlJS1KRJEw0ZMkRNmzbNsKhPTk7WunXrNGXKFK1Zs0Z+fn5aunSp6cOf2P/Wn3nmGU2ePNlp3eDBgzVjxgwZhqHXX39dQ4cOddn/vffe0zvvvKMWLVrol19+MTVrgwYN9Pfff+ujjz5yGZrz3nvv1YEDBzRt2jRHI+56YWFhGjZsmBo1auSYk8pMbdq00ebNmzV69GiNHDnSZf2YMWP0ySefqHjx4tqxY4cKFSrktN4df1v2v5169epp7ty52bqb/syZM+rSpYt27NjhlvOA/fPYsGFD/fDDD465+c6fP69HH31Uv//+u2NIrk8++cRl/+eff17fffedHn30UU2bNs3UrNL//rYeeeQRl7rE/jTsmjVrVKdOHcfNGNdy17HVXl/Vq1dPP/30k+P4mZKSot69ezuaK88//7wmTJjgsr/95+zZs6c+/vhjU7O+++67CgkJUbFixTRz5kw1btw4y/v+/vvvevrppxUdHe2W84CV6kErZZX+97dhl5U78a/njr8taleyWomVateePXvq559/zvB8PnjwYM2cOVOTJk1Sr169HMtPnz6tDh066J9//tHYsWP10ksvmZbTSjV2165dtWTJEnXr1k2ff/6507rx48drwoQJMgxDISEheuGFF1z2f/311/XRRx+pY8eOmjVrlqlZrVS7SlK5cuV09uzZm3oNd13Yvrb2TE1N1ccff6x3331XycnJeuCBBzRixAg1aNDA9ByZoXaFla5lSml/r7OfB6pWraqlS5emeSw7d+6c2rZtq71795p+zpKsVbtmBw1CIBMVK1a86fHX3XU3U3BwsI4dO6aFCxe6PBkiXb2TsFWrVrLZbPr1119dTrzuOiA0bNhQ+/fv14wZM1werV6yZIm6du3qeIIhreJq+fLleuyxxxQcHOwyzFNOq1Chgs6cOaONGze6jBddqVIlxcXFadu2bekOv7Fz5041a9ZM5cuX1+7du03N2rJlS23fvl1vv/32Dc1v8Mknn2jMmDFq0KCBli9fbkLC/3nwwQe1ZcuWNLOGhobqlVdekWEY6TYyvvvuOz3//POqW7eufvvtN1OzSv/7zH7xxRdpzs9lLxL8/f21detWlyGZ3PW3deedd+rEiRNp3plqX7dkyRI1bNgwzf3tf3933nmnNm3aZGrWJ554QkuXLlX37t312WefZXv/fv36afbs2Wrfvr1mz55tQsL/uf322xUbG6s//vjDaa4pSTp06JDq1q0rwzC0Y8eONO+AtW9TtGhRx/wOZilevLiSk5P177//ujSBS5QooaSkJB07dsyl0WYXFxenihUrqkiRIoqIiDA1q3T1gkBCQoJ27tyZ5vDXycnJuueee3T06FENGTJEb7zxhtN6d/xt1ahRQ5GRkY5GVXb9+eefat68ucqUKaN9+/blfMBr2OuAlStXulx83LZtm1q2bCnDMNI8p0lX7zRt0qSJSpcurb/++svUrJJUuXJlxcTEpJsnKipKd999t86dO6fJkyfr6aefdlrvrmNrrVq1FBERkWZdsmXLFrVu3VqGYWjLli2qVq2ay/47duxQixYtVKFCBe3atcvUrPfcc4/Cw8M1Z86cdIdmzYj9PFCtWjVt3brVhIT/Y6V60EpZ7e83aNAgnTp1SoZh6Iknnkh3igHp6hPmhmG43KgxevRoU3NSu5JVyv4Tr2lxxxOvVqpdq1atqtOnT2f4PfXgwYOqV6+e6tSpo7Vr1zqtW7dunTp27Gj6dwIr1dj2miWt3+lff/2lhg0byjAM7dq1K815u8LDw3X33XerRIkSjikrzGKl2lWSTp06pRdeeEG//fabDMNQ7969033S1mazOebK+vXXX53WZaexdKPSqj3tzfQlS5bIMAzde++96tOnjx5++GGPPdFG7Woeq1wjttK1TCntv62aNWvq+PHj+uGHH9S6det09129erU6d+6sWrVqOQ2jagYr1a7ZQYMQyETPnj21ZMkSXbp06YZfw11/ZEFBQbp8+bKOHz+uggULprnNtU8RXf9FwF0HhJIlSyoxMTHNC9hRUVGqWrWqDMNQRESE4+mHa8XGxqpSpUoqUKCAY04Ns9gvqEdFRbnML2e/EB8bG5vumPNXrlxRYGCgAgICdPr0aVOzli1bVufOndORI0fSHEI2M/Hx8apQoYIKFy6sY8eO5XzAa9izHjhwwGXYklOnTqlatWoyDCPN9dLVO/arV6+uQoUK6fjx46Zmlf73mQ0PD3e6y/paHTp00IYNG/TQQw/p66+/dlrnrr8t+zHAPrxNWutOnz6d7heVS5cuqUSJEsqfP79Onjxpalb7BYE9e/bc0JyHERERCg4OVrFixUwvrosVK6YrV67o1KlTLsMsJSYm6rbbbpNhGGmul/73e/Xz81NMTIypWe2/17SOr+XLl9fZs2fTPJ5dnzVfvnw6deqUqVml/30uo6Oj5efnl+Y2v/76q3r06KG8efNq+/btTp8Xd/xt2Y/1Gf3eMpKUlKTixYsrb968ioqKMiHh/9g/q2kdA679rKa1XpIuXryokiVLyt/f32UOQzPzZnRc+vjjjzV27FiVKFFCO3fuVP78+R3r3H1sjYyMdHp/6X/nTsMw0v2MXLhwQaVKlXJLLWCvW9L7b5wZ++fEHccAK9WDVspqFxcXpyFDhmj+/PkqWLCgxo8fn24jxlMXBahdySpJVapU0enTp2/qqVd3fH6tVLvaz1sxMTHKkydPmtvYv6emVffb60Gzj1lWqrEzymo/zxuGobi4uDSnnHBnVivVrtf68ssv9frrrysxMVGPPvqoPvjggzSfzMkNcxCm9d7btm3Tm2++qXXr1skwDBUuXFjt27fXQw89pCZNmqR7jc4M1K7msco1Yitdy5TS/tvK6HN8LftnwB11tpVq1/RcP9KI9L+66/rlhmG4zAuZm6Vd8QA5YMaMGYqNjVX//v21dOlSGYah0NDQNO8K87R8+fLp8uXLSk5OTnebsWPH6ueff9auXbs0ffp0p+FE3CU1NVXS1cfWr3ftI+NpXWCR5Ci409o/p5UpU0aHDh3S33//rVq1ajmtK1WqlI4cOaKoqCiVKlUqzf3tBUp6T+vkJPuB/EaGkbp2/5u9GyorkpKSJCnNeU2uXZbe783+RSGjz7oZMvrv+O6776pp06ZasGCBNm3a5Bh+zJ2KFy+uEydOKDo62mWc+FtvvVWnT5/WxYsXM2wQSkr3QkJOunDhgqSrX7ZvhL1Re/HixRzLlJ7ixYsrMjJSf//9t2rXru207to7gI8dO5bmHXj2wu9GCsjsqlWrln777TfNmzdPffr0cVpnvzFk27Zt6d5hu3HjRkly2wTfJUqU0PHjx/X333+rZs2aaW7ToUMHNWvWTGvXrtWAAQO0YMECt2S7NuOxY8ccc4tll/1JvOLFi+d0NBeFChVSfHy8oqKiXJ4WuvYCT0xMTJoXN+Pi4iTJLXM3SFeP5bGxsYqKikr3Ymv//v01ffp0HTlyRK+//rpH5msICAhwNLKvr/+KFCmiW2+9VT4+PulehLMPm+WOY2uhQoUcFwMyemIsPfbGsDsuYlmpHrRSVruiRYvq66+/1pw5czRy5EgNHjxYixYtUmhoaLo3O7kbtas5rJRVulpLLV26VKNHj9a///4rwzDUp0+fXPM5tbNS7VqsWDGdPHlS//77b7pPh9i/p6Z1g5a9YZjeheOcYqUau2DBgjpz5oyOHj3q8sRVgQIFHHMqp9UclKQTJ044tjWblWrXaz333HNq0aKFnnvuOc2dO1ebNm3SJ598YvqcjTnlnnvu0cKFC7VhwwaFhYVp8eLFmj17tubMmSNfX1/dddddqlevnmrXrq3u3bubmoXa1TxWuUZspWuZ6bnlllsUHR2daZ1oP6/a63UzWal2TU+jRo1c3n/Dhg0yDEONGjXyUKqckfYZGMghgYGBCgsLc1wwq1evnho3bpytf+5gL1SvH2rhWsWKFdOYMWNks9n06quvKjw83C3ZrlW6dGlJSnO4kjx58mjz5s36/fff093f/ni7OybM7tixo2w2m8aOHetyUce+LqMhYuzjedetW9fUnJJUvXp1SUpzfsmssA/Lk9YwbznNXjyl9d/52mUHDhxIc//9+/dLcs9nQJKj2WZvnqQlODhYvXr1ks1mU79+/XT+/Hm3ZLuWfWjhTz/91GVd06ZNJUkrVqxId3974yW9Cwk5yV78r1y58ob2X716tdPrmKlp06aO48C1dwomJSVp7Nixjv//zTffpLn/zJkzJcn0+WYk6YUXXnAc3xctWuS0buDAgWn+HHZxcXEaPXq0DMNQx44dTc8qSffdd59sNpveeOONDC+cf/jhh8qXL5/WrVuncePGuSWbnX1o7iFDhmT77sno6GgNHjxYhmHowQcfNCnh/9jPNWkNfXbtfDmrVq1Kc3/7MCc1atQwIZ0re94vv/wy3W38/Pz04YcfymazKSwszOVz7Q6VK1eWJM2fP99lnY+Pj44cOaLDhw+nu/+6deskyWX4aTPYh5F68803b2j/N998U4ZhpDsUdU6yUj1opazX69atmzZt2qQmTZo4hhoze66urKJ2NYeVskpXL5K1bdtWP/30k6O58txzz2n06NHZ+mc2K9Wu9usPac0tZmc/9951110u68aPHy/J/O+wVqqx7Q3M6+dKtPvmm29cRpG51o8//ijJPTWWlWrX61WpUkUrV67UqFGjFBUVpS5duujll19WYmKi27PcqMaNG2vmzJk6cOCA3nnnHd1xxx26cuWKtm3bps8//1wDBgwwPQO1q7mscI3YStcy09OiRQtJynS48zVr1khyz/nVSrVrehYvXqxFixY5/bO7frknvnvfDBqEMF3hwoVzfSe9S5custlsGj16tH744Yd07554/vnn1ahRI50/f15dunRxfAl0l5YtW8pms2nEiBFpznFUvXp1x0H3esnJyRo7dqwMw3A0PMw0ePBglSlTRmvWrFHLli3122+/Oe4UGT58uCpUqKAJEyZozpw5TvtduXJFkyZN0kcffSTDMNKcqDyn9e3bVzabTW+//bbGjh2b5eHhoqOj9frrrzsKq+eff97kpFefCLLZbBo+fLj+/vtvx/J//vlHI0aMcPz/Dz/8MM3933//fbd9BiSpdevWjs/s0aNH093ujTfeUJkyZXT06FH16NHDcQe3uwwZMkR58+bV559/rlGjRjlN9j5y5EjlzZtXY8aM0cGDB1323bJli1599VUZhmH6HY2S9Nhjj8lms2ngwIHZHnt9xYoVGjBggAzD0OOPP25Swv95+eWXlT9/fq1du1YNGjTQyy+/rGHDhqlBgwZau3at6tSpo5IlS+qzzz5zKbK//vprffbZZzIMQz179jQ964MPPqghQ4bo4sWL6tGjh1q3bq3Q0FBt3rxZd955p4YOHao//vhDLVq00Lfffqtdu3Zp27Zt+uSTT9S4cWP9/fffKlOmjIYOHWp6VunqsNd+fn5auXKlGjZsqI8//ljLli1TbGys03aVK1fW+++/L5vNpkmTJqlXr17avn27WzKOHDlSxYoV0549e1SvXj2NGDFCy5cv18mTJ13uHExNTVVkZKSWLVum4cOHq169etq1a5eKFy/uMreXGfr37y+bzaYvvvhCffr00S+//KL58+fr2Wef1eeff65ixYopb968euutt1yOA3///bfeeustGYahRx991PSs0tUhemw2m6ZMmaIXX3xRf/zxR5pPVtx///2Oc1zv3r311VdfufVJrE6dOslms+mdd97Rl19+6XjSMivCw8MddcuNzKuSXS+99JLy5MmjefPmqWXLllq4cGGmN6ycP39eCxYsUMuWLfXjjz/Kz89PL7/8sulZrVQPWilrWsqUKaOFCxfqnXfe0YULF9SzZ089++yzTnWCJ1C7kvVat99++w097eQuVqpd7eeCH3/8UT179nQ8jWez2XTo0CENHjxYkydPlmEYeu655xz7LV68WG3bttXcuXPl4+Njej1opRr7mWeekc1m07fffqunn35aCxcuzNK8XMnJyZo5c6Y++OADt/33t1LtmhZfX1+NHj1ay5cv1+23366pU6eqUaNG2rZtm0fy3KjAwEANHDhQmzdv1t69ezVlyhR17tzZZahyM1C7mi+3XyO20rXMaz388MMaOXKkZs6cqaZNm8owDI0YMSLd4Tj37t2rMWPGyDAMtWnTxvR8VqpdvRFzEMIt3njjDU2aNElbtmzRHXfc4ek4LpKTk9W2bVtt375dhmGoUKFCqly5st58803Hk0V2p0+fVqtWrXTkyBH5+fmpWbNmWrlypVvGwj558qQaN26smJgYGYahGjVqqEKFChnevfLjjz/qn3/+0Q8//KB///3X8SRJ1apVTc0qXS2Qunfvrn/++UeGYahIkSKqU6eOypUrp3Pnzunnn3+WYRgqV66catSooeTkZP3555+Kj493NGxHjRplek5JGjVqlOOLkq+vr2rVqqXg4GCVKlVKBQsWlL+/v5KTk3Xu3DlFRkZqz5492rNnj1JSUmSz2TRo0CC9/fbbpuc8c+aMmjRpooiICOXJk0eVK1eWYRgKDw9XSkqKunbtqoMHD2r79u3q3r27Bg4cqNKlS+vYsWOaPHmyvv/+e/n5+WndunVuuQszOjpa9913n2OetGbNmql69erq0aOHy7Fg+/bt6tixoxITE1W+fHn16tVLr7/+utvmSVi4cKGee+45JSYmKn/+/GrWrJnq1q2rcuXKaceOHfr888+VL18+de7cWXfeeacuX76sLVu2aPny5UpJSdH999+vefPmmT7kweXLl9W2bVtt27ZNhmGoevXqatWqlWrWrKnSpUs7Pq9JSUk6f/68Tpw4ob1792rlypXav3+/bDabGjZsqF9//dUtQ58sX75cffr0UUJCgtOwEpUqVdKvv/6q3bt3q3v37rLZbCpatKhKlSqlEydOOI4D3bt3T/OpLrPMmTNHb775piIjI7P839Jms6l+/fqaPn2624YYla4e3wcNGqSLFy86sn711Vfq0qWLy7aTJk1yeoLQZrO55W8rPDxcvXr10p49e5x+nz4+PsqfP7/8/PyUnJysxMREp5tzbDabateurenTp+v22283NaPdu+++q5CQEJe5nPLmzat58+Zp69ateuONN5Q3b161bt3acWxdsWKFkpKSVKdOHa1cuTLdOSFz2rBhwxQWFuY03Mq0adNc/vtfuXJF3bt317Jlyxw1jv3v0ez//pcuXVLbtm21Y8cOR87ChQsrIiIi3X1eeuklHThwQFu2bNGVK1dUtmxZrV+/3i0XhX7++WcNGDBAFy5ccAx3Vr58+XSPrREREUpNTZXNZlPBggX12Wef6aGHHjI9p5XqQStlzcyBAwf03HPPadeuXSpdurSmTJmiLl26eGw+J2pX7856vREjRujLL7/U5s2bc933bavVrt99950GDBjguKEmf/78unz5si5fvizpam3w3HPPOQ3d3bhxY+3Zs0f58+fXxIkT9eSTT5qe00o19ssvv6ypU6c61SwZzc3UsGFDHTp0SMnJybLZbGrWrJl++eWXdIchzUlWql0zcunSJb366quaOnWqfHx8NGTIEEezNbfNQZibULu6R26/Rmyla5nXzzd6/TWMunXrOp7El6Tjx49r7NixWrRokS5duqTbbrtNv//+u4oWLWp6VqvUrtlhlWNbZmgQwi1iY2MVGRmpatWqpTuHl6dduHBBY8eO1axZs3Tp0iUZhpHuhdZTp06pd+/eTsMmuuuAcODAAfXv319//PFHlt63VKlSunjxomw2mwoXLqwvv/zSLXcz2SUnJ2vGjBmaNm2a03A8hmGkO/Z0/fr1NWrUKD3wwAPuiinpaoNowoQJ2rNnj2NZWg2Ca3PXrl1bo0aNUrt27dySUbo6Z0Tv3r21detWp+WdO3fWl19+qX///Vdt2rRx+dJlbwh8+OGH6t27t9vy7t+/X71793Y8OZDR39a6dev09NNPKz4+3vEZcefJNjw8XG+99ZYWLlyo1NTUNCcgvr55kD9/fvXr10+vvPKKWy5aSFe/uIwdO1YzZsxQUlJSlhpZ9kZH79699cYbb6Q7b4IZYmNj9d1332nPnj3y8fFRcHCwevTo4Zhzav78+Xr55Zed7iLLnz+/Bg0a5Bi6052Sk5O1ZMkSLVu2TDt37tShQ4dchhb19/dXxYoV1bBhQz388MMem+Pj2LFjmj59un777TcdPnxYH3/8sTp16pTmtuvWrdN7772njRs3Oj7f7vrbWrx4sebNm6cNGzY45udJS6lSpdS4cWN16dLFrecqu1WrVmnq1KlOn9Xhw4erTp06kq5egP3iiy8kOZ/H7EMi3ej8Sjfql19+0SeffKIdO3YoJSVF06dPT/PYmpKSogkTJig0NNRxZ7G7/vsnJiYqJCRE33zzjWJjY7NUt9jnq7r33nv1xRdfuGXYG7sTJ05oypQpmj9/viIjIzPdvnTp0urUqZMGDRqkkiVLuiHhVVaqB62UNTNXrlzR+PHj9dFHHzkusHnyogC1q3dnvdauXbu0ceNGdevWzS0XpbPLarXrtm3b9NZbb2nDhg1OT95XqlRJw4YNU48ePZy2f+GFF1S6dGn16NFDlSpVcltOK9XYK1as0DfffKPt27crOjo6w6dH7LVAkSJF9Oyzz2rUqFFuv45kldo1M6tXr1b//v116tQpj56zrHQRndrVfFa4RmyVa5mXLl3SoUOHdPDgQZd/cXFxqlGjhtMw6StXrtQjjzwiSapZs6ZmzJjhlqly7KxSu2aVlY5tGaFBCFwnISFBmzdv1uHDh3X//fdneLfypk2btGjRIu3atUvHjx/Xzp073ZZz//79+uOPP3T69Gm99NJL6W7XsGFDlSxZUi1atFCPHj3ccldIeo4dO6adO3fq4MGDio6O1sWLF5WSkqL8+fMrMDBQVapU0b333uuxIsXu0KFD2rBhg8LDw3X8+HGdP39eycnJ8vf3V8GCBVWmTBlVrVpVjRs3dusXwOvt3r3bcWdjrVq1VLNmTaefYcyYMVqxYoWuXLkiX19f3XvvvRo5cqSaNWvmkbyrV6/WmjVrdPjwYfXr1y/dYSXi4uL05ZdfasmSJdq3b5+uXLni9pNtTEyMli9f7vi8xsTE6MKFC0pJSVGBAgUUGBioypUrq2HDhmrdurXLXVvuEh0drcWLF2v9+vWOz+uFCxeUlJSkgIAAFShQwPF5bdKkidq1a+f2BkZWJSUladu2bTp16pSKFSum+vXrK3/+/J6O5XDu3DmnY1bhwoXdchezGc6ePau9e/fq+PHjeuKJJ9z+/hcuXEj32FqgQAG358mu3bt3a9GiRYqKilJgYKCaN2/uMtqAu50/f15Hjx7VbbfdpsDAwHS3S0xM1Jo1a7Rr1y7HxQR3OnLkiE6fPq369eunu83LL7+sMmXKqHnz5mnO7+ROhw4dyvTY6sk6QLJWPWilrJnZsmWLnn/+ef3777+54qIAtat3Z7USq9WuCQkJOnz4sJKTk1WyZEmVLVvWY1luVG6vsdPy008/qVy5cqpbt658fX09HcfyteuZM2f02muvOebO88TcWN9++60kuTTXcztqV0jWuZZ5vTNnzujUqVNOT2lu3bpVU6dOVadOndSmTRuPXdOwSu2amfHjx8swDLfM6WwmGoQA8B+WkpKimJgY3XLLLW696zanXLlyRadPn1apUqU8HQUAAAAms1LtaqWsAAAAQFpoEAIAANPUqlVL+fLl07vvvuuxYTj/y2JjY/XPP/+oYcOGTstTUlL0888/a+3atYqMjJS/v78qV66sDh06qEGDBh5Ke/VJzEOHDunYsWM6f/68EhMTHXe1li5dWlWqVNEtt9zikWz9+/dXvnz5NHz4cN12220eyXAjEhMTlS9fPpflkZGRWr9+vU6ePCk/Pz9VrlxZTZo08ehTA1euXNHu3bt14cIFlS9fXuXKlct0n71790qS09M77hYfH68LFy4oMTHRcVdrRk9q5japqamKjY3VLbfc4rY5MjOTmppq2aewAavKDcdTK7BK7WqVnFaXm2vX68XFxSk8PFxxcXE6f/68fH19VaBAARUrVkyVK1f22Kg3knXr7IwkJSXpyJEjOnfunEqXLp2rnh6zeu0qyTFHar9+/TycJH2RkZGO79oVK1ZUoUKFPB1JEnU2so8GITyuSJEi8vHxyXCS6tyCrOawUlbcmMTERIWHh8tms+n2229XwYIFHetiYmI0Y8YM7d2711Fc33///Xr44YfdOi9GcnKyJKU5Bv6lS5c0a9YsLV26VAcPHlRSUpKKFi2qu+66S4899phHh5NKSEjQpk2bdPDgQUVEROjChQu6ePGiy1AijRo18siXV/uY7IZhaOjQoRo9enSuuUBtZWfPntXo0aP1ww8/qEaNGlq3bp1j3T///KMePXooPDxc0v/G77f/PbVp00aff/652z4PZ8+e1bRp0zR//nzt3r073Tkb7GrVqqVHHnlEffr0cTpWmM3+WS1WrJi++OILt8+Dm12zZ8/WZ599Jh8fH61du9axPDExUSNGjNDs2bOd5k2SpMKFC2vEiBEaOHCgu+Pq/fff18cff6xz5845lgUHB+v1119Xy5Yt093PEzXC1q1btWDBAq1fv16HDh1yzNt4rbx586py5cpq2rSpunTporvvvttt+exsNpvWrVvnNAzitcPdHjx4UGPHjtXy5csdwyA2atRIo0aN0n333ef2vL///rvef/99bdq0SZcuXVKZMmXUvn17DR48OMOLauXKlZNhGDp69KhbcqampmrdunXat2+fbDab7rzzTrVo0cKxfu3atfrwww+1d+9enT9/XqVKldIDDzygwYMHe2T4wcTERK1du9YxTFN6F7GrVq2qZs2aqUWLFsqbN6/bc0pXzwfTp0/Xxo0bHTcKtG/fXh06dMhwvx49esgwDM2aNctNSa2VNatyy3cuatecYZWcVmSV2lW62hQMDQ3V/PnzdfDgwQy3rVChgtq0aaNevXqpWrVqbkp4ldXq7MOHD+vbb7/VX3/95agF+vTp4xjZKCQkRKGhoU517R133KExY8aoY8eObs9rldo1Ozx9zjp06JCmTp2q6OhoTZ061Wnd999/r/fee0+HDh1yLPP19VWTJk302muvqV69eu6Oa5k6W7JW7Wq3f/9+hYeHO+qWa5vv9qzBwcEezXgzaBDC46w0oSdZzWGlrMiec+fOaeTIkfrxxx8dDbi8efPq+eef17hx4/T333+rQ4cOio6OdvriZb/Q+e2337rtYlt6Bej+/fvVvXt3/fvvv2l+OTQMQw8++KC++OILt17E2LRpkyZOnKh169Y5mgDp5ZOuFqwtWrTQyJEjdc8997gtp/3vu2nTplq7dq2qV6+uKVOmuDXDf8358+fVunVrxxfWli1b6qeffpJ0teHeuHFjx1NjHTt2VLVq1ZQvXz7t2LFDv/76q1JSUnTPPfdo8eLFpl9I+u2339SnTx/FxcU5Pp9FihRRqVKlVKBAAfn7++vSpUs6f/68Tp486fiSbRiGihcvrhkzZritkXHthYuYmBg9/fTTevvtt1W4cGG3vH92PP/88/r+++9ls9lUq1YtrV+/XpJ0+fJlPfTQQ/r9999ls9l02223qUqVKsqbN692796tqKgoGYahXr16adKkSR7JGxAQoMKFCys6OlrS1WPTxIkT1adPnzT3dWeNcOrUKT333HOOhntmFwSl/x1jW7Vqpc8++8xtc2WFh4fr6aef1v79+52WN2/eXLNmzVJERITat2+vuLg4l319fX318ccf66mnnnJLVkmaNm2ahg8frtTUVJfzfWBgoObOnau6deumua87PwN79uzRM88845inye7uu+/W3LlztXnzZj355JNKSUlx+TkKFiyoWbNmqXnz5qbnlK42Mt9//319+umnjt9NRp9Z+2f11ltv1dChQ/Xiiy+6I6bD1q1b1b17d8XExLj87ho0aKA5c+akO9+ku78rWClrdng6G7VrzrJKTquxUu26evVq9ezZUwkJCY6sPj4+Sk1Ndcp08eJFp0aWj4+PnnrqKU2cONFtwyNbqc7+9ttvNWTIEF2+fNnpRsuiRYtq4cKFWrp0qd58803H9nnz5tWlS5cc273++usaOnSoW7JaqXbNLk+es2bOnKlhw4bp8uXLCg4OdnzXkqRXXnlFn376qeN37efnpzx58igxMdHx/6dMmaJu3bq5La9V6myr1a6HDx/W5MmTtXDhQsXGxma6fdGiRdWpUycNGTIkSyPl5CY0COFxnv6ikh1kNYeVsiLrLl26pNatWzvuujQMQ/7+/kpKSpJhGBo1apTWrl2rTZs2qXz58urQoYOCgoIUHh6un3/+WRcvXlS1atW0du3aNIfPy2lpfQ5jY2PVsGFDRUVFKX/+/OratasaN26swMBAJSQkaPPmzZo1a5YSEhJUv359LVmyRL6+vqZnnThxosaPH+/48leuXDkFBwerVKlSKliwoPz8/JSUlKRz587p5MmT2rdvnyIiIiRdvdjy5ptvuu0Jomt/r19++aXeeOMNXbx4UY899phef/11lSlTxi05/kvGjRunDz/80HEH7rVPX73yyisKDQ1VpUqVNHfuXFWuXNlp3127dqlz586Ki4vThAkT9Pzzz5uW86+//tL999+vxMREValSRf3791fLli0zLJYjIiK0cuVKffHFFzpw4IAKFiyoNWvWqEqVKqbltLN/Vg8dOqSXXnpJv/zyi4oXL67XXntNTz31lFufaM7IjBkzNHjwYPn4+Gjw4MHq27evSpcuLUkKDQ3VK6+8ogIFCmjixInq3r27I3dqaqrCwsI0evRopaamas6cOWrbtq3peefPn6+nn35aPj4+Gjt2rPr376+AgACdPHlSr776qn788Uf5+vpq8eLFuvfee132d1eNEB8fryZNmuj48ePy8/NThw4d1LJlS9WqVctxbL32omBkZKT27t2rlStXatGiRUpOTlbFihW1du1a0y92xcTEqFGjRjp16pTy5cun2rVry9fXVzt37tTFixfVoUMHHTt2TDt37lTXrl01aNAglSlTRseOHdPHH3+suXPnyt/fX+vXr9cdd9xhalZJ2rlzp+6//36lpKSoVatWGjJkiIoXL64///xT77//vv755x/dcsst2rRpk+OzfC13fQZOnjyp++67T3FxcQoICFBwcLAKFiyoPXv2KC4uTp06ddKOHTt09OhRPfzww+rWrZuKFSum8PBwhYaGau/evSpSpIh+//33NH+OnJSamqpHH31Uq1evls1mU8mSJdWiRQsFBwerdOnSLhexIyMjtW/fPq1Zs0aRkZEyDEPt2rXT7NmzTc1pd+rUKTVs2FBxcXEqWbKknnnmGRUvXlw7d+7UDz/8oKSkJNWoUUOrV69O8w5xd98oYJWsr732Wra2nzx5sgzD0KBBgxzLDMNwutBtFmrXnGeVnFZipdo1PDxcTZo0UWJiou699169+uqratCggfz8/LR37169++67WrRokXr37q1JkyYpPj5eO3bs0Pz58/X9998rKSlJTZs21fz5891S41qlzt6xY4datmyplJQUVa1aVe3bt1fBggW1ceNGrV69WrVq1dKRI0eUnJyst956S926dVOhQoV07NgxTZo0SV999ZUMw9CKFStMf0LPSrWrpGzfQPXnn3/KMAzVqVPHscwwDP322285G+w669ev10MPPaTU1FQ1aNBAL774omP0gMWLFzsaf926ddPLL7+s22+/XT4+Pjpw4IDeeecdLViwQH5+flq3bp1q1KhhalbJOnW21WrX2bNna+jQoUpKSnLc5Fq1alWnm0WurVvCw8OVnJwswzCUL18+hYaGqkuXLm7JmhNoEMLjrNQcIqs5rJQVWTd58mS99tprKlKkiCZMmKBOnTopb9682rZtm5599lmdOHFCKSkpqlu3rhYsWOA0HMvRo0fVvn17HT9+XG+99ZbThQyzpPU5HDNmjD755BOVLFlSCxcuTPOL3vHjx9WuXTtFRETo/fff17PPPmtqziVLlqhr166Srg5jNXTo0Cx9AQ0PD9fkyZP19ddfyzAM/fjjjxkO65dTrv+9/vvvvxowYIA2btwof39/de/eXS+++KJuv/1207NkJrsX2tLijgttderU0ZEjRzRjxgx16tQpzXU//PCDWrduneb+P/zwg/r27au6deua+gWrd+/e+umnn9SqVSvNnj07zeF703PlyhV169ZNy5cv1+OPP66wsDDTctpd/1n96aefNGzYMMXHx+uOO+7Qyy+/rEcffdTjFzCaNWumXbt2pXl3sn3dhx9+qN69e6e5/4QJEzR+/HinJ0/N9PDDD2vt2rXq27evJk6c6LK+T58++vHHH1WxYkVt3brV5XPirhohs+Z6Rg4fPqxHHnlE//77r1588UXTjwH2c1P16tU1d+5cx5P2J06c0GOPPaa//vpLktL9Ev34449r2bJleuaZZzR58mRTs0r/OxY0b95c8+fPd1qXkJCgDh06aNeuXWmul9z3GRg1apQ+++wzValSRd9//73jvHT+/Hl17dpVGzZskCQ99thjLseklJQUtWvXTlu2bFH//v01fvx4U7N++umnGj16tPLnz68PPvhAXbt2zdJcMzabTT/88IOGDh2qixcvauLEierbt6+pWSVp9OjR+vTTT1WpUiWtWrXK6em7PXv2qFOnToqNjdVzzz2n9957z2V/d35XsFJW+3vZ2W/IS8/1Q47btzc7K7Wrd+eUrFNjW6l27d+/v7799ls1b95c8+bNS/Mm1R49emjRokWaPn26Onfu7Fh+4MABPfzww4qKinLbecAqdXavXr00b948tWrVSnPmzHEabeWll17StGnTHDc7jxo1ymX/gQMH6ptvvtFjjz3mMixlTrNS7SpJxYoV05UrVyRl7UnHtLjjnNWpUyf99ttvevTRRzV16lSnz6T9e02/fv307rvvprl/z5499fPPP6tr16764osvTM0qWafOtlLtunnzZrVr104pKSlq0qSJhgwZoqZNm2Z4TkhOTta6des0ZcoUrVmzRn5+flq6dGmuH8rXjgYhPM5KzSGymiM3ZK1YseJNF6P2O+LMlhNDV7njziv7heqPP/5YzzzzjNO6efPmqVevXjIMQz///LPT3D7Xb1OvXj2tXr3a1KxS2p/DunXr6vDhw5o2bZoeeeSRdPddsGCBnnrqKd1zzz1auXKlqTk7duyo9evXa/DgwRo3bly293/jjTc0adKkdAvEnJbe3/fChQv19ttv68CBA/Lx8VGzZs30zDPPqE2bNm55YjQtQUFBunz58g3v764Lbfacx48fd5nnpHjx4kpOTtapU6fSHaf//PnzKl26tAoWLKgTJ06YlrNq1ao6ffq0tm3bdkN3Uf/999+qX7++SpQooX/++ceEhM7Se4p4woQJmjFjhpKTk1W2bFn17NlTTz75pEqUKGF6prTcdtttunTpksLDwxUUFOS0rmTJkkpMTNThw4fTHf4uKipKVatW1a233qojR46YnrdChQo6c+ZMup+Dc+fOqW7duoqOjta4ceM0ePBgp/XuqhFq166to0ePatGiRWrUqFG299+wYYPat2+vihUraufOnTkf8Br2c9P8+fNd5sBds2aNYw7fVatWpTkHytatW9WqVSuVL19eu3fvNjWrdHVOnlOnTmnlypVpfkkODw9Xo0aNlJycrK+//loPPfSQ03p3fQbq1aunQ4cO6aeffnKZG2ndunXq2LGjDMPQunXrVKtWLZf9N27cqHbt2qlq1aratm2bqVkbN26svXv36tNPP1X37t2zvf+3336r/v37q3bt2k5z2JrF/plN78nl5cuX67HHHpOPj4/WrVvnMoeLO78rWCnr1KlTNXbsWF24cMFxZ32RIkXS3X727NkyDMNl2LPPPvvM1JzUrt6dU7JOjW2l2rVGjRqKjIxM95wkSbt371aTJk3UsGFDLV261GndokWL1L17d9NvGLSzSp1tr1nWr1/vcnzfuXOnmjVrJsMw9Mcff6TZfN+3b5/uu+8+lSlTRvv27TM1q5VqV+nqTTbPPfec/vrrLxmGoZ49e2Y4JHL//v1lGIZCQ0Odlvfo0cPUnGXLltW5c+e0Y8cOVapUyWlduXLllJCQoN27d6f7ZHF4eLjuvvtulSpVymUqADNYpc62Uu36xBNPaOnSperevfsN1Uj9+vXT7Nmz1b59e7c98XizaBDC43JDcyiryGqO3JC1Z8+eWrJkiWPs+Bvhrp+hRYsW2rFjx029hjuyli5dWhcuXNA///yj4sWLO607ceKEatSo4WiqBgYGuuxvv4hduHBhHTt2zNSsUtqfQ3uzJSIiIsNhN86dO6cyZcq4JWv58uV19uzZNJsDWXH69GlVqVJFt9xyi1smos7o79tms+m7775TSEiIjhw54hiO4YEHHlCLFi3UtGlTtwwtaZeQkKA5c+YoJCREcXFxWbrYlhazL7RVq1ZNUVFR+vvvv12+PFeqVElxcXE6ceKEChQokOb+Fy5ccAyNERkZaVpO+99PVFTUDc1vkpSUpOLFiytv3ryKiooyIaGzjD6rJ06c0Pjx4zVnzhylpqbKx8dHDRs2VMeOHXX//feratWqpuezszfc0moQ27/QRkdHpzu/ZHJysoKCghQQEKDTp0+bntd+t3BGmb7++msNGjRIRYoU0Z9//ul0TnBXjWClz6s9a1qfAfvft2EY6R4H7Ocsd38GTp48me7FaXsD4Pbbb9fWrVuVJ08exzp3fwaOHTumQoUKOa2LjY1VpUqVZBiGIiMjlT9/fpf9ExISVLZsWeXLl0+nTp0yNav9ZoCMjvUZsd8oYvZ5wM7+uz1y5Ei68zU/9dRTWrBgQZpNIHd+V7BSVkk6ePCgnn/+eW3fvl2lSpXSJ5984tLg9lQ2O2pX784pWafGtlItYG+6xsTEOJ0zr3X58mUVK1YszZsC7fWCJ79r2+WmOjujmsV+njcMI93fe2Jiom677Tb5+/s75ts2i5U+r3bJycl68803FRoa6pgu4ZVXXknzd+mpc5a9xkrr91qiRAklJSUpNjY23allrly5osDAQLd8BiTr1NlWql1vv/12xcbGas+ePY6RWrIjIiJCwcHBKlasmFseIskJaZ9FADc6e/aspyNkGVnNkRuyzpgxQ7Gxserfv7+WLl3quFOpfPnyno7m4rffftO+ffs0cOBA7dixQ4Zh6NVXX1XJkiU9Hc1JcnKyJKX5GP61DcO0moOSHBffbqZpe7MKFCig5OTkdC9q29mHyEhKSjI9k31Yjhu9A9j+e7W/jifZ72Lv2rWrli9frq+//lrLli3TwoUL9euvv0qSChcurNq1a2vhwoWm5ylcuLCef/553XPPPY6nWseOHeuWObqyo379+lq4cKG+/vprDR8+3Gndvffeq8WLF2vdunXpzi+3YsUKSVefnDZT6dKl9e+//2rLli1q2rRptvffunWr43U8rXTp0goNDdWwYcP01Vdf6bvvvtOGDRu0ceNGSVePafXq1VOdOnU0cuRIU7NUr15dv//+u5YtW+byZHP16tW1detW7dmzJ92J6P/8809JV59EdIdixYrp1KlTOnr0aLpDHz311FOaOnWqdu/erWHDhmn69OluyXatokWL6tSpUzpy5IiqVauW7f3tF61vvfXWnI7mIm/evEpOTtaZM2dcGoTXfrk/d+5cml/AL168KCnt87MZChYsqDNnzujcuXPpnruGDRum2bNn6/Dhw/rwww81YsQIt2S7Vp48eZScnKzz58+7NAivbRSl1RyU3FMD2OXNm1eJiYnp/jfOjLs/A/7+/kpOTs5wnua3335by5Yt09q1a7Vw4UJ17NjRLdmuZ6WsklS5cmWtWLFCEydO1MSJE/XII4+oT58+evvttz32tNj1qF3JaZUa20q1a5EiRRQTE6OTJ0+mewE7owv+9mswKSkpZsTLltxUZ+fPn18JCQk6ceKES91aqFAhx3x46TVl7TdepTeSS06yUu1q5+/vr7fffltt27bVCy+8oA8//FArVqzQl19+qerVq7stR0YqVqyov/76S3/++afL/OgVKlTQ33//rYiIiHS/S7v792qVOttKteuFCxckXf0eeyPsN0PZM1tB5oO9AoCXCAwMVFhYmOOkWq9ePTVu3Dhb/9zlzjvv1HfffedoXHXo0EE9evTI1j+z2RuWaT3t6Ofnp++//17fffdduvvbh2O4kTuNc8p9990nSZkOFbZ582ZJ7vkyaP+icqNzh/3yyy+S5Na7hjNjGIYefPBBffvttzpw4IDefvttNWrUSH5+fjp79qzWr1/v1jx169Z1GVImNxk4cKB8fHwUEhKiTz/9VKmpqY51L730knx8fPTaa68pNjbWZd/Dhw9r9OjRMgwjw2Fzc8JDDz0km82mAQMGOOZEy6q//vpLAwYMkGEYevjhh01KmH0VK1bUW2+9pQMHDmjWrFlq3bq1AgICFBUVpcWLF6c7F0VO6tmzp2w2m4YPH+5o9tk9++yzstlseuedd9LcNzk5Wa+99poMw0h3jsqcZh866P333093G8Mw9NFHH8nHx0c///yzW+acvF7Tpk1ls9k0YsQIJSYmZmvfpKQkDR8+XIZh5Mgw4JmxH5/mzJnjsu7aZZs2bUpzf/sxNTtz1dwMe96MhtgpWLCg3nnnHdlsNr333nvasmWLW7Jdy35TWFpDhfv6+ioyMjLDYZnttUKZMmXMCXiN2rVrS5ImTZp0Q/t/9NFHkpTujQQ5zT4M26pVq9Ldpnz58ho8eLBsNpuGDBnilrvu02KlrHY+Pj4aOXKkVqxYoSpVqmjq1Klq1KiR6UPdZhW1q+fktpy5vca2Uu3aoEEDSVfn9UqP/bx75513uqyzD9tYs2ZNE9LdmNxQZ9eoUUOSNGvWLJd1hmFo7dq1Wrt2bbr724dydcfxykq16/UaNWqkTZs2qVu3btq9e7eaNWvmlnmxs6JLly6y2WwaOXKkEhISnNY98sgjstlsGX5XmTRpkgzDUMOGDc2OKsk6dbaVatcKFSpISvs7QVbYp0iyv44V0CCEWyQkJGjp0qX65JNPNGLECA0YMEC9evXSCy+8oJdfflmTJk3SokWLLDEcZm6RkpKiefPm6eWXX9YLL7ygd999N0vzyIwePVqvvPKKGxI6O3PmjOLj412WX758WT/88IPGjh2roUOH6v3337/p4TNvRuHChW9o/HZPKFGihMsdTblJkyZNZLPZNGrUKMXExLisb9Omjdq0aZPu/uPHj5dhGG7/GV988UWFhobqt99+U7du3WQYiigQ2wABAABJREFUhkaOHJnu8enkyZN65ZVXZBhGukM65aSnnnrK8UVg6tSpWb6b+sqVK5o2bZqGDRsmwzBc5oXMLYoVK6ZBgwZp0aJFioiI0Ny5c9W/f3+358hoPgRPa9CggUJCQpSamqpXXnlFtWrV0siRI/X999/rypUrGjBggMLDw3Xvvffq3Xff1cKFC/XTTz9pxIgRatq0qSIjIxUcHKyBAweamnPYsGGqVKmSIiIi1KRJE3Xt2lVTp07Vli1bdOzYMcXHx+vChQuKi4tTRESENm/erLCwMD3xxBNq0qSJ44mzYcOGmZrzRvj6+qpjx4764YcfFBERofnz52vw4MHpzgGTk5544gk9+uijio2NVatWrfTss8/q119/VWRkpB5//HH16dNHq1at0sMPP6wNGzYoPj5ep0+f1sKFC/XAAw9oy5YtKlKkiNt+ry+88ML/sXfmcTXl/x9/nhIhzNjSQgZlLNmHQQlji+zDDGbs+zJEtmEwBsNg7Ixd9n2LCqFUjGVsRWhBUWmR9rot5/eHxz3j6haZ7qn7/d3n4+HxmOmcT/fVuZ/zOe/zeW9SqbNevXpx4sQJHj16lGMjo0mTJsyePVta3xYsWCBL+Usl06dPx8jICC8vL5o3b8769et5/PhxnmMePXrE+vXr+eqrr/D09KRMmTKyROQOHz4cURRZtmwZCxcu5Pbt29y5c4eFCxeydOlSSpUqhZ6eHgsWLMgRKBAdHc2CBQtkdb5///33iKLIokWLWLFihVqbAKBfv3706tWLjIwM+vfvr/Gevu9jb2+PKIrMmTMnR68meFtVILeI59jYWObMmYMgCHTo0EHTUpk0aRIAmzdvZujQoR/dO+ju3bsMHTqUjRs3SqW95KBr165SYENem1LTp0+nbt26xMTE0Lt370JxvGmT1vdp3LgxPj4+jBkzhpCQEDp37szChQsLPfNOZ7sWDYqKzqJsY2uT7Tpx4kREUWTTpk3Mnz9fxZGRlpbGypUr+e233xAEgcGDB0vHbt++zahRo9iwYQOCIDBu3DiNa80vhWln9+/fH1EUWbt2LXPnzuXevXsfvU95+fJlFi1aJJuNpU22qzrKlCnDpk2b2Lt3L0ZGRsybNw97e3tZSknnxcSJE6lbty53797FxsYGZ2dnXr9+DcDkyZNp0qQJGzduZNmyZSrVrmJjY3F0dGTPnj3o6elJtpqm0RY7W5ts1379+iGKIhMnTuT8+fP5GnvhwgUpWKR///4aUljw6HoQ6tAoV69eZfny5Vy5ckUqXaAsxfcugiAAbw2Bdu3aMXPmzCJtOBY2ISEhfP/991Lja2XTbngb0bJx48Zca5DLWcc7KyuL5cuX4+zsTEREBPA2q8zJyYkRI0YQGRmJg4MDQUFBOf6OLl26sHnz5nz3JSgIlPW5r1+/XuTKnrzPnDlzWL9+fZHUGhgYiJ2dHSkpKZQsWRI7OzuqV6/O0qVLcx1z/fp1goKC2LNnD9euXUNfX5/z58+rbbZc0Lw715Tz8F3atGnD6dOnpf+PjY1l/fr1ODs7ExsbS9myZbl69eon1SjPLz/88AMuLi4IgsDnn3+OnZ0d9evXx9TUlDJlymBgYIBCoSAxMZHw8HD8/f3x8vLizZs3iKJI79692bVrl8Z1QtHoMfopXLlyBVdXV6ZNm1aoWax54e3tzS+//CJlkambt++iXGP79u3LqlWr8uyrWVDExsYyYcIE3NzcPkoj/GsnODg4sHbt2lzLEBc02jRXldGfq1evJiUlRbquxYoVk0oj5TbOwsKCvXv3yrLJomTt2rXMnz+f7OxsSeuOHTvo06dPjnMdHR3ZsWOHdJ5y3srxvVy7do2hQ4cSGRkpfb6BgQEmJiYYGRlJa2tSUhKRkZFkZGRIGk1MTHB2dpYi+jXN+PHj2bdvn9p7ytnZmRs3brB+/XoqVarEd999h5mZGWFhYRw6dIjY2FiqV6+Or69vjhKlmkAURQYOHIirq6ukt0KFCmzYsCFHoFBSUhIODg7cuXMHQRCwtLTkyZMnssyBN2/eYGdnJ/XrKlu2LNWqVcPHxyfXMatWreLx48e4uroSHx/P559/ztWrVzE1NdWoVnib/fHLL79IWeQVKlSgfv36mJmZYWRkRPHixUlPTycpKUmyBWJjYxFFEX19fZYsWcLYsWM1rhPelru1s7MjODgYQRCwsrKibt26TJo0iaZNm6qcGxgYSOfOnXn9+jVly5alb9++0pogxzqgTVrzwtPTk3HjxhEREYG1tTWbN2+mZcuWhaZNZ7sWPNqi832Kuo2tTbbrn3/+ya+//oogCBgYGFCjRg3S09MJCwsjKysLURTp3r27SjacjY0Nfn5+6OnpMX36dNmCx7VlvmZnZzNw4EDc3Nyk714QBLXB7kr69etHQEAAL168QBRF6tevj4eHhyxlnrXJds2L6OhoJk6ciLu7O2XKlGHRokVMnjy50OZMbGwsw4YNw8vLC0EQEAQBCwsLqdqEp6cngiBgaGhIjRo1UCgUhISEkJWVRbFixVi9ejU//vijLFq1xc4G7bFdMzIysLe35+bNmwiCQJ06dejYsWOuWl++fIm/vz8eHh4EBAQgiiItW7bkzJkzuZYjLmroHIQ6NMby5ctZsmSJdONXq1YNa2trTE1NpQdVeno6iYmJRERE8ODBA0JDQ4G3jsKFCxdqPLtBG4mPj5ei00qVKkWvXr2oXLkyd+/elR5Stra2nDp1Cj29nEnCchlm2dnZ9OvXj4sXL+ZwCguCwMqVK7lw4QJubm6UK1eONm3aUKlSJQIDA/H19UUURZo3b46bm1uePUA0QWxsLOHh4dSuXVu23iyfytOnT3n48CFt27b9pDremsbHx4fRo0dLJbk+NPdMTU1JSUlBFEWKFSvGihUrGDZsmCxaAwMDCQoKyvEvMjISeFtu5Nq1a9L5Hh4eUonGKlWq4OzsLGu24/r161mzZo2UYZPXy6vyHjQ2NsbR0VHWSFFteRnUZu7cucO5c+e4e/cuQUFBREdHk5KSQlZWFqVLl6Z8+fJYWlrSsmVLevToUSgluvz8/Dhx4gQ+Pj4EBgZKUZjvUr58eaysrLCxsaF3796ylzzSxrkaGxvLvn37OH/+PPfu3cvVMVi6dGmaN29Or169GDhwYKE8227dusXGjRvx8vIiJiaGnTt3qnUQAuzbt49ly5ZJEcRyfi8pKSns2rWLkydPcuvWrTx78xQrVoxmzZrRu3dvhgwZInu/r507d7Jt2zYePnyIIAjUq1ePOXPm0KVLFxQKBUOHDuXs2bMqzwdRFKlZsyaHDx+WrcQovLUL169fz8aNG6WgsdzmQFJSEk5OThw6dEh6j5BrDkRFRTFjxgxcXFzIzMzMl91iYWHBzp07cziRNMmdO3dYvnw5Fy5ckHo/KxEEIYcNXqJECTp16oSTk5PUR0kuIiMjmTRpkhSJLQhCroECDx8+ZNCgQYSEhEh/h5zrgDZpzYv4+HimTp3K0aNHKVGiBOnp6YWqTWe7FizaolNb0QbbFeD06dPMmzePp0+fqvy8TJkyjB8/npkzZ6rsp/Ts2ZPKlSszcuRIWR1D2jRfRVFkx44d7N69G39/fzIzM6WejeowNTUlOTkZfX19+vTpw/Lly2Xt66dNtuuH2LVrF3PmzCE5OblIPE/d3d3Zvn073t7eHyzjamRkRJcuXZg+fbrswfvaYmeD9tiuaWlpzJs3j127dkn204cQRRFDQ0OGDx/OggULck3cKYroHIQ6NIKbmxvff/89AIMGDcLR0fGjNiQDAwNZu3Ytu3fvRhAEjh49KkuZHm1i8eLF/PHHHxgbG3Pu3DmVxrgeHh4MHjyYlJQU5syZw/Tp03OMl8sw27lzJ1OmTKF48eI4OTnRp08fjIyM8PX1xcnJCYVCQUpKCpaWlpw6dUol0vrmzZv079+fuLg41qxZU2TLyej4ODIzM/Hw8OCff/4hOjpaqh2ujmrVqlG5cmXatm3L6NGjsbKykk9oLiQnJxMUFMTr169p166d9PMrV66wZMkSevbsyY8//ihLFsb7KBQKfH198fb2JigoiLCwMJKTk0lPT6dEiRKULl2aqlWrYmlpia2trdRzRIeOwiY1NTXHXC3sF1RllpCc/WQLmqioKKKjo0lOTiY7O5tSpUpRoUIFWfqj5ofExEQMDAwwNDTM87yHDx9y9+5dXr58qdam0TRpaWk8ffo017W1Ro0aReLFT/lyry4w7MyZM5w9e5bIyEgqVqxI27Zt6d+/f6E+Cx4/fkxISAj169fPM+s+NDQUNzc37t27x8uXLzl16pRsGuPj47l37x5RUVF8++23uZ7Xr18/zM3Nadu2Ld26dSu0KOGUlBSuX79OYGAgL168ICkpCYVCQfHixTEyMsLc3BwrKyuaN29OqVKlCkWjksDAQLy8vAgJCaFfv340btxY7XkZGRkcPXoUV1dXaQ6o662r0/phTpw4wZQpU3jz5k2hb7bqbFcd2kpRtF3fJSAggMDAQBQKBSYmJjRt2vSDdpacaKudnZGRwevXrzE2Ns71nNWrV1O1alUp6L0w0RbbNS+ePn3KlClTCAkJAd466wub9PR0Hj16lCMYV/muZWlpibW1dZFIMNAGOxu0x3aNjo7G1dUVb29vSev795ZSq62tLV27dqVixYqFpvdT0TkIdWiE7t274+3tzeTJk/n111/zPV5Z4rFt27ayLFIF4YASBEGWsictW7YkICCAzZs389133+U4vm/fPsaPH0/x4sW5ceOGigMR5HMQdu7cmevXr7NgwQKmTJmicmzPnj1MnDgRQRDYu3cvDg4OOcbv2rWLyZMn07p1a1xdXTWqVUfR4d0yszp06NChQ4cOHTp06PjvJCYmSiXyqlWrVshqdOjIG2VFBDnK4evQoUOHDh3/39E5CHVoBAsLC+Lj4wkMDPykCJqoqCgsLS357LPPZGlQa2lpSVRUVI4STPlBrmhMExMTUlNT87y2Dg4O+Pj40KNHD3bv3q1yTC4HYbVq1UhISODBgwc5MheeP39OgwYNEASBJ0+eULly5RzjX7x4Qb169WSbAzp06NDxLsqeN++Xh8nIyODEiRP4+/uTmJiImZkZ7du3p0mTJoWkVD3nz5/H3d2d4OBg0tLSKF++PI0bN6Zv377UrFmz0HQpo5tDQ0NJTk4mNTVVihI0MzPDysoKa2vrQtHm4OBAyZIl+fXXX6lbt26haPhfJjs7m+fPn+cIXAK4ceMGXl5ehIeHU7x4cWrVqkWXLl1k6en6IV6/fi1FYaekpKhEiqqzX+Ri6dKllCxZklGjRhV6RlhBoFAouH37tsocKAq9lWNjY0lKSsLc3PyjSt4XpU1tZWSzDh06Po2srCxOnTqFr68vycnJWFhY0K1btw/28J09ezaCILBkyRKdzk+kXLly6Onp5dn3TS50tmvBoE1atZ2iaruqIzIyUrK19PX1MTIyomLFioWegfW/ZmcrSU1NJSkpiQoVKqitPFLY6GzXwkPnINShEczMzEhOTubFixefVHYvKSlJavyp7F2mSURRxN3dndmzZ/P06VMEQWD48OH5dm7Onj1bQwr/RekgjIyMzLVkhJ+fH23atEEURVxdXWnVqpV0TC4HYcWKFcnMzFQ7B9LT06lcuXKeOlJSUjAxMcHAwICYmBiNas0PRell5UNYW1sjCAL3798vbCkfRKdVR1EgKyuL5cuX4+zsLNXuNzExwcnJiREjRhAZGYmDgwNBQUGAasZrly5d2Lx5M+XKlZNFq6WlJXp6ejx+/Fjl5xEREQwZMoQbN25IGpUIgoCenh7Dhw9nyZIlspVACQkJYe3atbi4uHxUybXy5cvTq1cvpkyZImuWg/L5aGhoyNKlSxk6dKhsn/2/TEZGBitXrmTr1q2YmZlx5coV6VhUVBQjR45U+ZkSfX19RowYweLFi2UtL5ednc3x48c5ffo03t7eeT7vy5YtS5s2bejbty+9evWSNQNeOV8tLS1xdnYu8pttPj4+bNq0iYSEBFxcXKSfi6LIihUrWLduXY4emjVr1mTBggV0795dbrkcPnyY5cuXExgYCLydj507d2b27Nl5bgQXhp348uVLzp49K/XJUm4KKtf/kiVLSpvYbdq0oUePHiql/eXk6dOn+Pv7IwgC9evXp3r16tKxmJgYVqxYgaurK69evaJixYq0a9eOKVOmyNovU0lISAjr1q3j6tWrKk6XYcOG5VlW0MbGBj09PbXrmia1Pnz4EFEUqVu3rkog0OPHj9mwYQN+fn4kJSVhampKhw4dGDZsWKGUx4e3Dhdlqa7cNrEtLS2xs7OjXr16haIxJCSE77//nidPngCqNl/fvn3ZuHFjrpuYcvZa0xad+aWwtels14JHm7RqG9piu8Lb9jP79+/n5MmT3Lhxg6SkpFx1Nm7cmM6dO/P9999Tvnx5WXVqm50dHx/PqVOnePDgAaIoUq9ePfr16yc5N/fv38/y5culXqUlSpTAzs6OGTNm0KxZM9n1apPtCm8DAK9evUpQUJAULPK+3WJlZUXr1q357LPPCk3nf0HnINShEezs7Lh3794n94/bu3cvEyZMoHHjxnh6eha8wFwIDg6mWbNmiKLI33//XSQil9+nRYsWPH78mGPHjvHNN9/ket7UqVPZvn071atXx9fXV3oBlMvYrlOnDhEREZw7d05t8+stW7YAMHr0aLXj79+/j62tLcbGxtILT1GgsF9W8oNOq2bQJq06Pp7s7Gz69evHxYsXc2SQC4LAypUruXDhAm5ubpQrV07qMREYGIivry+iKNK8eXPc3Nw+Ksvkv6JuHiYlJdGuXTtpQ/ubb77BxsaGChUqkJCQwN9//42bmxtZWVl069aNffv2aVzn/v37cXR0JD09HVEUKVGiBFZWVpiamlK6dGmKFy9Oeno6iYmJRERESL1TBEGgZMmSbNiwQW1zdU2gvKZWVlY8efKEtm3bsm7duiKRxaatZGZm0rdvX7y8vBBFkaZNm3Lp0iXg7Xxt3749T548QRRFmjVrRu3atTE0NOT27dvcuXMHQRCwt7fnwIEDsuh98OABQ4YMISgoSGUdKF26tDRf09LSpAwCJYIgULduXZydnT+q53ZB8O5GW3Z2NjNmzMDR0VGW9Se/LFq0iBUrViCKIg0aNMDb21s6NmTIEE6dOoUoiujr62Nubo6hoSHBwcFkZmYiCAK//PIL06ZNk03vwoUL+fPPP9VWEylZsiQ7d+7E3t5e7Vg5bYTk5GRmzpzJwYMHyczM/KjqJ4IgYGBgwODBg1m8eLFs/aliYmIYO3YsHh4eKj//8ccfWbVqFZGRkXTr1o3nz5/n+DtKlSrFrl276Ny5syxaAVxdXRkxYgSpqak5Am1q1KjB8ePHVZyb7yLnHHj58iVjxoyRensp6dWrF5s3b+bu3bv06dNHZdMN3v4dpqamHD58mPr162tcp5KDBw+yYsUKlUCr3FBuWteuXZvZs2fTq1cvOSQCbzdabW1tef78OaVKlaJXr15UrlyZu3fv4unpiSAI2NracurUKbUZGHLNAW3RCbB169Z8ne/k5IQgCNKzQ8moUaMKWloOdLarZtAmrdqENtmuDx48YMCAAYSGhn50xTZBEChdujSOjo44OTlpWOG/aJOdffHiRUaMGJFjLa9evTouLi54enoyadIktdfcwMCA9evX8/3338uiVZtsV4CrV6+yfPlyrly5QlZWFqDedlHaLPr6+rRr146ZM2fy1VdfyaazINA5CHVohG3btjFt2jQMDQ1ZvHgxQ4cOpVixYh8cl5mZibOzM3PmzCEtLY1Vq1YxbNgwGRT/S4cOHbh161aRdRD+8ssvrF27llq1anH8+HEsLCzUnpeQkEDLli15+fIldnZ2HD58mBIlSsj2IjB06FBOnDhB8+bNcXFxyfciPmLECI4dOybrxuDHoE3OIZ1WzaBNWnV8PDt37mTKlCkUL14cJycn+vTpg5GREb6+vjg5OaFQKEhJScHS0pJTp06pRLDdvHmT/v37ExcX98mBMflF3TxcunQpv//+O+XKlePAgQO0bt06x7h79+7Ru3dvXr9+zdatW+nXr5/GNP7999907dqVrKwsbG1tmTJlCm3atMkzc1GhUHDlyhXWrVuHp6cnBgYGuLu7yxLZqLymUVFRLFy4kA0bNlCiRAkmTJjA1KlTKV26tMY1/K+xevVq5s+fT6lSpVi8eDEDBw6U7AHlfK1UqRI7d+7E1tZWZaybmxvDhw8nNTWVv/76S+MvrmFhYdja2hIXF0f58uUZMmQIHTp0wNraWm1mcFxcHA8ePMDDw4M9e/YQExNDpUqV8PHxoUqVKhrVCv/O15s3bzJ27Fhu3bpFvXr1WLJkCW3bttX4538sp0+f5scffwSgT58+TJgwQbqflX2z9fX1cXJyYsqUKVKkc3x8PH/88Qfr169HEATc3d35+uuvNa7Xy8uLHj16IAgCw4YNw9HRUdpwX7hwIb6+vhgaGuLl5aX2PUEuGyEtLY1OnTpx//59ycHeoUMHGjRogKmpKUZGRhgYGKhsYvv7+3Px4kVu3ryJIAg0bdoUNzc3jWeTvxu8Iooipqam6OvrExYWJlVtCQ4OxtPTE1tbW8aPH4+5uTlhYWGsX7+eq1evUqZMGa5duybLRnJQUBA2NjakpqZibW3NuHHjpDmwefNmoqOjMTMz4+rVq2qjxOWaA2/evKFNmzbSRmvlypUxMjLi2bNniKLIiBEj+Pvvv/H396dp06b0799fCmzauXMnkZGRmJqa4uvrK0tmxqRJk9izZw+iKGJoaEizZs2wtrbGzMxMZRM7KSmJ8PBwHjx4wK1bt0hLS0MQBEaNGsXy5cs1rhNg8eLF/PHHHxgbG3Pu3DmV0tgeHh4MHjyYlJQU5syZw/Tp03OMl2sOaIvOdz/rY1FuwL4/RtNadbar5tAmrdqCNtmukZGRtGjRgjdv3lCjRg2cnJxo0aIFJUqU4P79+yxfvpy7d+8ya9YsxowZQ2hoKLdv3+bkyZNSwEO/fv3yHWzwqWiLnR0YGEibNm1ISUmhQoUK2NnZUaZMGW7cuEFAQAB2dnYEBAQQExPDhAkTGDBggGQLrF69mvPnz1OiRAl8fHywsrLSqFZtsl0Bli9fzpIlS8jOzgbettGytrbOVeuDBw8IDQ0F3joKFy5cyMSJEzWus6DQOQh1aIwffvgBFxcXBEHg888/x87Ojvr162NqakqZMmUwMDBAoVCQmJhIeHg4/v7+eHl5SX2fevfuza5du2TXPWPGDLZs2VJkHYTR0dG0atWK6OhoDAwMsLOzo06dOgwaNCiH3lu3btG9e3dSU1OxsLBg2LBhzJ8/X5YXgdu3b9OxY0eysrIwNTXFwcEBCwsLJkyYkOuY8PBwgoODcXZ25siRIwiCwPHjx2nfvr1GteYHbXIO6bRqBm3SWhQoCGeZIAgafx507tyZ69evs2DBAqZMmaJybM+ePUycOBFBENi7dy8ODg45xu/atYvJkyfTunVrXF1dNaoV1M/Dr7/+mkePHn0wuEa5KW9nZ8fp06c1pvG7777D3d2dgQMHsmnTpnyPHzduHPv376dbt27s379fAwpVef+aXr9+nXHjxhEcHEyFChWYMGECo0aNKhK9xQrq5VjTkfjKqgerV6/OUUpKOV+3b99O37591Y7funUrTk5OstxXP/30E87OzjRt2pQjR45QoUKFjx775s0b+vTpw+3btxk2bBirVq3SoNK3vDtfs7OzWbNmDb///jsKhYJvvvmGGTNmqK3gIDfKtXXcuHH8/vvvKsc6derEjRs38swQnD59Olu2bKFHjx7s2bNH43oHDBiAq6srffv2ZceOHSrHlBmxnp6eNGrUSNqwehe5bITff/+dpUuXUrFiRZydnbGxsfnosdeuXWPw4MFER0fn6jgoSJTBAObm5uzevZumTZsCcPfuXX744QdevHgBQMuWLXF1dVW5ptnZ2XTu3FnaoFu6dKlGtcJbR9bu3btp1KiRtHGm5MWLF3Tt2pXQ0FD69OmTY46AfHNg0aJFLF++HBMTE3bs2CG1lAgPD+e7777Dz88PgPbt23P06FGVDLL4+Hg6d+7Mo0ePmDFjBj///LNGtb4bDDBjxgzGjRv3USXZExIS2Lx5M0uXLiUrK0vjgU1KWrZsSUBAAJs3b+a7777LcVz59xQvXpwbN27k6K0r1xzQFp0A8+bNY926dWRnZyMIAl999VWeG7w+Pj4IgpAj2O3s2bMa1amzXTWHNmnVFjtbm2xXJycntm7dSqNGjTh79myOEtcZGRn06NGDa9eucerUKezs7KRjnp6eDB48mISEBNmeA9piZyttlqZNm3Ls2DE+//xz4G3rlOHDh3Py5EkEQWDMmDEsW7Ysx3il3Tt06FDWrFmjUa3aZLu6ublJwamDBg3C0dHxozJtAwMDWbt2Lbt370YQBI4ePUqHDh00qrWg0DkIdWiU9evXs2bNGqKiooCcEWDvoowSMzY2xtHRkXHjxsmi8X3u3buHr68vAwYMkBbXokZAQADDhw/n4cOHwNvrumPHDrWlLK5cucLgwYOJi4tDEASpL4EcLwJHjx5l8uTJUl3xD32usnelci44OTnxyy+/aFxnftAm55BOq2YoCloLImpNEAQuX77838V8AEtLS6KiolTW/48tKaJEjutdrVo1EhISePDgAWZmZirHnj9/ToMGDRAEgSdPnqht7v7ixQvq1avHZ599xvPnzzWqFdTPwypVqpCWlia9aOfG69ev+eKLLzSutWbNmsTGxuLn5/dJWR+hoaFYW1tTsWJFgoODNaBQFXXXVKFQsGXLFlatWkVMTAylS5emX79+/Pjjj4XSr+F9rf8VTd9XlStXRqFQ8PTp0xw2lbGxMenp6YSFhVGmTBm145VztVy5clJEpqaoW7cu4eHhkvMnv9y5c4e2bdtibm7OgwcPCl7ge6ibr0+ePGHevHm4ubkhCAJff/01I0aMoGfPnrL1HH0fU1NTUlJS1K6t5ubmJCUl8fjxY4yNjdWOV64DlSpVksoSapJatWoRExODr6+v2t5nr169olmzZiQmJrJ27VoGDx6sclwuG+Grr74iMDCQAwcO5FruNC+UGx+1a9eWetZqCqUTQ12AzZkzZxg0aBCCIHDmzBm1m0Wenp707NkTS0tLbt26pVGt8LbXdFhYGC4uLjkym+FtAGbHjh0RRVGtZrmdQ7t27cpRflP5/QqCkGu7h/Pnz9OvXz+sra1zlCgtaJQVehYtWvRJ0fTr169nzpw5tGjRgvPnz2tAoSomJiakpqYSGBhIpUqV1J7j4OCAj48PPXr0YPfu3SrH5JoD2qJTybVr1xgzZgzPnz/H2tqaLVu25NrXq7Det3S2q07ru1r/K5qev9pkuzZs2JDnz5/j5uZGy5Yt1Z5z/fp1OnXqRPv27Tlx4oTKMWXAg42NjcYDBUB77OwGDRoQGhqq9lmvvJ6CIHD9+nVq166dY/zt27dp164d1atX5969exrVqk22a/fu3fH29mby5Mn8+uuv+R6/YMECVq1aRdu2bTl16pQGFBY8OgehDo2jUCjw9fXF29uboKAgqfloenq61NCzatWqWFpaYmtrS+vWrTEwMChs2VrBpUuX8PT0JCQkhHHjxqktJwdvN9i2bNmCm5sbDx48IDMzUzZjOzY2lmPHjvHPP/8QFRWV40H/LiYmJgDY2toybtw42rVrJ4vG/FAUnEMfi06rZigKWtu1a8ft27f/0++Q628QRRF3d3dmz57N06dPpXJiuW1k5Mbs2bM1pPAtFStWJDMzkxcvXuSIaExPT6dy5cp5XrOUlBRMTEwwMDAgJiZGo1pB/TysWrUqiYmJREVF5fmSotRavHhxoqOjNaZR6bCMiIigZMmS+R6fmppKlSpVKFWqFBERERpQqEpe93ZycjLr169nw4YNxMfHIwgCVatWpXv37rRr147WrVtLpRHlIDAwkF27drF161bS09MRBIFGjRrluzyTpl+wlRtt6hyEFhYWxMfH8+rVK5UMnXdJS0vD2NiYkiVLEhkZqVGtSmdmXnryQrlOGBoa8urVKw0oVCWv+Xrz5k0WLlzIlStXEASBsmXL0q1bN3r06IGtrW2ONU6TKNcldeuAcnM7JiYm11YEmZmZVKhQQePrlRLlsyCvdXTNmjXMmzcPY2Nj7t69q3Lvy2UjKB3s/3V9lePeUmp9/vx5jqyx+Ph4qlWrhiAIao/D25Jo1atXl+3eqlSpEhkZGWrtASXKrI1GjRrh5eWlckxu55C69fXVq1dYWVkhCAKhoaFqM3JiY2OpUaMGpUuXJjw8XKNalevAs2fP1JZl/RDKOVC2bFnCwsIKXuB7KK9tZGRkrm0y/Pz8aNOmDaIo4urqKmVwgvxzoKjrfJekpCRmzpzJ3r17KVGiBHPnzuWnn37KcV5hvW/pbFedVtAeO1ubbFel1rzsK4VCQaVKldQGBiYkJFC1alU+//xznj17plGtoD12ttJmCQ8Pz3GPKJ+dgiDkOkeSk5MxNTWlRIkSUmKPptAm21X5nppXAE5eREVFYWlpKVvweEGgcxDq0AjKLDVt4P+bVuWmx7v9szTBp2iNiIjA2NhYbRN1HflHaVRVq1atkJV8GJ3W/PPgwQMmTpzI7du3EQSBuXPnSk72j2XQoEEaUpeT4OBgmjVrhiiKRbKEc506dYiIiMg10n7Lli0AjB49Wu34+/fvY2tri7GxMU+ePNGoVlD/0tKrVy88PT25ePGiVMJNHdeuXaNLly5UrVoVf39/jWlUlpDcs2cP3bt3z/f4s2fPMnDgQOrWrcu1a9c0oFCVj9mMSkhI4NChQ+zevZv79+9Lz7lixYpRu3ZtGjVqxIYNGzSuVcmFCxf49ttvEQShSN5XvXv35vLly6xcuZIRI0aoHOvZsydeXl65Zg0BXLx4kT59+siSOaTMGvrQ/ZMbyijsatWqSaX9NMnHzFcfHx+2bt2Kq6srCoUCQRDQ19encePGNG3alIYNGzJw4ECN6mzXrh137txRW2KnTZs23L9/P8+56+/vT+vWrTEzM5MqZ2iSj8keycjI4KuvvuLZs2c5+qLJtamtzHS8e/cu1atXz/d4OTMzlRVC1GXgR0dHU6tWLQRByDX7XU5HFvxbUSAkJCTX3nwxMTE0btyYxMTEHGW95XYSBwUFUbFiRZVjSsd6XjrkdLwqr6k6Z+bH8ObNGywsLGTJJod/y2MfO3aMb775Jtfzpk6dyvbt26levTq+vr7SprBcc0BbdKrD1dWVSZMmERsbS8uWLfnrr7+wsLCQjheWNp3tqtP6LkXdztYm27V69eq8efMm12o88O9zSZ2DPSYmhpo1a8riHALtsbOV1Tju3bunsobC2zLtNWrUQE9Pj5CQELXjw8PDqVOnjiw2ljbarnkFi+VFUlISZmZmGBkZ8fLlSw0oLHh0u/A6NMIXX3zB2LFjOX36NMnJyYUtJ0/+v2ktVqyYxp2D8FbrmDFj8qXVxMRE5xwsQKpVq1boTqyPRac1/9SrV4+DBw9KGdcODg4MGjQoX//kpGbNmp/04iIXLVq0QBRF5s6dS1paWo7jo0ePztU5CG8zSpSNs+VkxYoVnDlzhuDgYMaPHy/9DRkZGWrPT05OZu7cuQiCoLZ0WkHSr18/RFFk4sSJ+S4JduHCBSZMmIAgCPTv319DCvNP2bJlGTVqFN7e3vj4+DBy5EiqVatGRkYG/v7+7Nu3T1Y9HTt2pFatWrJ+Zn4YO3asNCffj6KeOHEioigyb948tffc69evmT17NoIgfNImXX5RlgycMmVKviNoo6OjmTx5MoIg0LlzZw0pzD82NjY4Ozvz6NEjFi9ezJdffklmZiY3b97kr7/+yrMvdEExYMAARFFk2rRpUq85JT/88AOiKPLnn3/mOv63335DEASVXjSapEmTJsC/QSHqMDAw4M8//0QURbZu3SpLqav3UQayLFy48JPGL1y4EEEQci3zVZAoN1RdXFxyHHu3D+4///yjdvzNmzcBPmkz6VNQluA6c+ZMrudUrFiROXPmSOtbYGCgLNreRVmy9+rVqzmOFStWjL///jtPB8X9+/eBtxlTmqZOnToAans2fgzKPtTqyv5qgk6dOiGKIjNmzMgz8n/BggWYm5vz/PlzBg0aRHp6uiz6lGiLTnV07dqVGzduYG9vz9WrV2nVqhXOzs6FLUtnuxYyRU1rUbeztcl2bdy4MUCe/aSVdoK6Xm/K797KykoD6j6NomBnK+enujKWenp6PHv2LFfnILxtSQXk6FGrCbTJdlVe12PHjn3S+JMnTwLq53JRRZdBqEMjbNy4EXd3d65evYqenh6tW7emW7du2Nvb5+g/UtjotGoGbdL6Lv7+/jx58iRHP8c3b96wY8cOvLy8CA8Pp3jx4tSqVQsHBwf69u1bqI7NgIAAAgMDCQ0NJTk5mdTUVIoXL46RkRFmZmZYWVlhbW1daPo+Bj8/P1xdXYmMjKRixYq0a9dOpQSO3Ny6dYurV6+SlJSEhYUFHTt2zDXSTYmykb3c/VOVvUWKYlTj+8yYMYMtW7YUSa23b9+mY8eOZGVlYWpqioODAxYWFnka9uHh4QQHB+Ps7MyRI0cQBIHjx4/Tvn17jetVlmF7N1Pb0NAQhUJBdnY23bt3V3kBS05O5vDhw6xbt47g4GBKlCiBl5eXtGmnCTIyMrC3t+fmzZsIgkCdOnXo2LEj9evXlyLqihcvTnp6OklJSbx8+RJ/f388PDwICAhAFEVatmzJmTNnci0/WJD8l2j1kJAQqez33r17C15cHkyYMIF9+/YVyfsKYP78+axevRpBEGjevDk9e/akadOmVKtWTeo7U7duXSZOnEj9+vVRKBRcv36djRs38vLlS6pWrcrVq1fVlsgrSF69ekWrVq2IjY2lTJkyDBgwgA4dOmBtbU2VKlVU7rXs7GwiIyPx8/PDw8ODQ4cOER8fj7GxMb6+vp9Uiia/fOp8DQsL4/Lly1y6dIkrV67kuWlQEGRnZ9OjRw+8vb0pV64cI0eOpFevXpJdMmDAANzd3Rk0aBAzZ86UAnDu3bvHokWLOH/+PCVLlsTb21uWl2xl9ocgCAwePJghQ4ZQp04dtaXNnJyc2Lp1K4aGhvz+++8MGTKE8uXLy5L18s8//9C5c2cyMzNp1qwZkydPpl27dnlGOSclJXHp0iXWrl3LrVu3MDAw4MKFC5/Utyg/bNu2jWnTpmFkZMTixYslh/+ZM2eYM2cOKSkpZGVlUb9+fS5evKhSKjE1NZV27drx6NEjpk6dyrx58zSqFd7ac7NmzcLIyIhVq1bx7bffqrXzRVGkW7du+Pr6Uq1aNQ4fPkydOnVky3yaMWMGmzdvxsTEhOPHj+fay00dCoWCjh07cu/ePX788UfWrVunQaVv+9KPGDECPT09Jk2axKRJkz5qnYyOjmb9+vWsW7eO7Oxstf0WNUF0dDStWrUiOjoaAwMD7OzsqFOnDoMGDcrxnL116xbdu3cnNTUVCwsLhg0bxvz582WZA9qi80Ps2bOH2bNnk5SURMeOHdmwYQOWlpaFok1nu2oObdL6LkXZztYm21XZP65YsWL88ccfDB8+XEXfkSNHcHR0JCkpicWLF0vv4BEREWzbto3Vq1eTlZWltiqJJtAWO3v16tXMnz8fQ0NDfvvtN7799ttcqx+8T2BgIN26dSMqKgonJyfmzp2rUa3aaLsaGhqyePFihg4d+lFremZmJs7OzsyZM4e0tLQcVSaKMjoHoQ6NkpCQwPnz53Fzc+PChQskJCRgbW1Nly5d6Nq1qxRFUhTQadUM2qI1LCyMcePG4ePjg7W1Nd7e3tKxa9eu8cMPPxAbG4soqi6ZgiDQsGFD9u7d+0mNzD+VkJAQ1q5di4uLC7GxsR88v3z58vTq1YspU6bInv124sQJNm/ejL+/P4Ig0KBBA2bPno2NjQ2iKDJ9+nS2bdsGqJamtbOzY+fOnR9t4BQEsbGxDB8+PEc/mRIlSjBhwoQ8N6bKlSuHnp4ecXFxmpapwpw5c1i/fj3Xr18vci8t73Pv3j18fX0ZMGDAJ5WY0jRHjx5l8uTJJCUlAR/u06gsPaFcF5ycnPjll1/kkIqHhwdBQUHSv+DgYF68eEF2djZAjtJGHh4e9O3bF4BSpUqxadMmWTbZ0tLSmDdvHrt27ZJ6eHwIURQxNDRk+PDhLFiw4JN6anwKRaG/6Kdw+vRpDh48yPLly4tsAM6BAwdYuHAh4eHhH11+XBRFmjdvzs6dOzE3N9ewwrcEBgYybNgw/Pz8VHTq6elRqlQpDAwMUCgUpKamSveaUmvDhg3ZuXMnNWvWlEWrNs3XtLQ0pk2bphL5b2BggJmZGYaGhgQEBEjX28jIiMzMTNLS0hBFkbJly7Jz584c5Uk1idLxp9QkCALbt2/PETyWmZnJwIEDOXfuHIIgUKZMGRISEmT7Xk6cOMGECRNITk5GEAT09PSwsLDIdRM7NDSU7OxsRFHEyMiITZs20aNHD43rzM7Opm/fvly6dEnt/b9s2TLu3LnDgQMHqFOnDsOGDcPc3JzQ0FC2b99OYGAgFStW5Pr16zlKaWoChUKBvb09t27dkr7XWrVqsXDhwhyZ91FRUXTs2JFnz55JDhoPDw9Z5kBERAQ2NjbExMQgCAJ169alevXq7N+/P9cxR48e5cmTJxw+fJinT59SsmRJrly5IktGxqxZs9i0aZNUgq1BgwZYW1tjamoqzVeFQkFiYiLh4eH4+fnh5+dHVlYWoigyadIkFi1apHGdSgICAhg+fLhU2lgQBHbs2JFjHYC3GRiDBw8mLi4OQRCk9xk51gFt0fkhnj9/zpgxY7h27Rrly5fn9evXhaZNZ7tqBm3S+i5F3c7WJtvV0dGRHTt2IAgCxsbGNGjQAIVCQWBgIOHh4YiiSIsWLTh79qxUJcnGxgZ/f39EUWTgwIFSULam0Zb5mpaWhr29vdR2Bt5m4uZVjnvq1Kk8evSI69evk5mZSdWqVfH29pZlf0ZbbFd4W+nExcUFQRD4/PPPsbOzo379+piamlKmTBnp3lLaLf7+/nh5efHmzRtEUaR3795SBQRtQOcg1CEbWVlZ+Pj44O7ujpubG0+fPsXExAR7e3vs7e1p27Ztrs1q5UanVTMUVa3R0dG0adOGiIgI9PT0GDBggFTb/vnz59jY2JCQkMBnn33GsGHDsLKyomTJkvzzzz/s3r2b+Ph4LC0t8fLyynfj6k9h//79ODo6kp6ejiiKlChRAisrK0xNTSldurT0UE1MTCQiIoLAwECpJnrJkiXZsGGD2pdGTfDzzz+zcePGHI7VYsWKsW/fPu7fv8/ixYspXrw4nTp1wtzcnLCwMC5cuEBGRgZNmjTh/PnzskRgpqWl0aFDB8mR2apVKypVqoSfnx9BQUEIgkC/fv3YunWr2vGFZUQ+ffqUhw8f0rZtW1nm3/86sbGxHDt2jH/++YeoqChOnDiR67nKno+2traMGzeOdu3aySVTLQqFguDgYIKCgkhISFApI+vh4cHkyZPp0aMHEyZMkM3hoiQ6OhpXV1e8vb0JDAzkxYsXJCcnk56eTokSJShdujTm5uZYWVlha2tL165dZdkIfhdteRHUVhQKBW5ubpw7d467d+8SHByco7Ro8eLF+eKLL2jZsiU9e/aUJRtXHa6urhw/fhwfH58cPVDexdTUFBsbG/r06YO9vb2MCrVzvgYEBLBt2zYuXLiQZzk8eFuWulevXkyYMEFtXzpNc/LkSdavX8/t27fJyspi586dam2nrKwsli1bxoYNGz46uKQgefnyJevWrePUqVMf1TvGzMyMXr16MWnSpHz3Lf4vZGRksGTJEnbs2CFdmwoVKvDzzz8zcuRI4uPj6dOnj+SUUyKKIuXLl+fQoUM0b95cNr3JycnMmzePvXv3kpaWlqfTJTIykuHDh+Pr6yv9TK458OjRI8aPHy+VZ/3Q55qampKSkiI537ds2SLr2uXi4sKyZctUel2pc768+97QsGFDZs2aRdeuXWXR+D7KrKWQkBDGjRtH69at1Z73+vVrtmzZgpubGw8ePCAzM1PW9VlbdOaFKIqsWbOGxYsXS++uhalNZ7sWLNqkVRvRBtsVYP369fzxxx/Ex8er/FxPT4/vvvuOFStWqGSU2dnZYWhoyOjRo6VgVznQpvmamprK0qVL2bNnD7GxsR9lCyjbQH399dds3rxZtjLuoD22K7ydr2vWrJFK+OYVMKK0XYyNjXF0dJS9sth/Recg1FFoBAQE4Orqiru7O7du3aJkyZK0a9eOrl270rlzZ9mNq7zQadUMRUXrtGnT2LZtG9WrV+fQoUMqWVg//fQTzs7ONGrUiJMnT+aIqnnx4gVdu3YlNDSUOXPmMH36dI1q/fvvv+natStZWVnY2toyZcoU2rRpk6djVaFQcOXKFdatW4enpycGBga4u7vTrFkzjWpVlpEQBIERI0bQvXt39PX1cXFxYevWrZQpU4a0tDTKlCmDm5ubSvRyQEAAXbt2JS4ujj///JPhw4drVCvAunXrmDt3LmXLluXo0aNSjXR42zNl+vTpZGVlsXr1aoYOHZpjvDYZkToKhoiICIyNjbWid2p2drZW6CxMlJGWRaHH6P8XEhMTpfKCpUqVomzZskVuniob1CclJaFQKKQS3ubm5oUalKHMxpO7n2xBERcXR1BQEDExMSQnJ5OVlUXp0qWpUKEClpaWRcZeTUpK4vnz51SpUiVPR2Vqaiqenp7cu3dP2viQm+Dg4A9uYteoUUN2Xe+SnZ1NWFgYenp6mJqaoq+vLx1LS0tj27ZtuLm5SSXn7ezsGDNmTKE4ieFtJZS///6bkJAQ2rdvn2em3dWrVzl79iz37t3jxYsX3L17VzadAQEBUmDT1KlTcz2vZcuWmJiY0K5dOwYNGiRrlY53CQ4OxsfHR5qv6tZXKysrbGxsCn3OfgqZmZlERUVhampa2FLypKjqfPbsmdSz1sbGppDVFG20yXbVJq3aTlG1Xd/V5+3tTVBQEAqFgipVqtCmTRu1AaxKW0ZutNXOfvbsGVFRUXkGVU2bNg1zc3Patm1b6BXdtMF2VSgU+Pr6SnM2LCwsh9aqVatiaWmJra0trVu3ljJgtQmdg1BHkSAmJgY3Nzfc3Nzw9PQkLS2Npk2b0q1bN7799lvZMx3yQqdVMxSm1nr16vHy5Uu1vcOUx9zc3HJthqt0hNWrV4+rV69qTCfAd999h7u7+yeXVxg3bhz79++nW7dueZYgKgh69uyJl5eX2p4xv/32GytWrEAQhFzrcm/ZsoXp06fTqlUr3NzcNKoVoG3btty9e5c//viD0aNH5zi+Zs0a5s2bR5kyZbh9+3aOnoQ6B6EOHTp06NChQ4cOHTp06NChQ4cOHTq0BZ2DUEeRIz09ncuXL0tlqIYOHcqsWbMKW5ZadFo1g9xaK1WqREZGBhEREZQsWVLtsaioqFyz9NLS0jA2NqZUqVJ5lnMoCGrWrElsbCx+fn6f1PMwNDQUa2trKlasSHBwsAYU/ku1atVISEhQqzUsLIz69esjCEKuf4tSa7ly5fKsoV5QKPvJPXz4UG0krSiKtGnTBj8/P4YMGcKaNWtUjuschP8NBwcHBEHAxcWlsKV8EJ1WHdrC9evX8fPzIykpCVNTU+zs7DA2Ni5sWSo8evSIc+fOERQURFpaGuXLl6dx48Z07dqVsmXLFqq2xMREgoODCQsLIykpidTUVClS1MzMDEtLSz777LNC0TZ+/HhKlizJ9OnTqVKlSqFo+F8nNTU1h10IEB4ejre3NxERERgYGFCrVi1sbW0pVapUIajMSVxcHMnJyaSmpkpZA4WVgadk//79lCxZkl69en10H9KiTnh4OOHh4VJp5DJlyhS2JEBXMaAgSU1N5cmTJwiCQM2aNVUyb9LS0tixY4dKxmu7du0YNWqU7H224+Pj2blzJ76+viQnJ2NhYUG3bt1wcHDIc9ygQYMQBIG9e/fKpPTtNQ0MDEQURWrWrKlSSjAmJoZdu3bh7+9PYmIiZmZmtG/fnp49exbaupGQkMDVq1cJCgoiNDSU5ORkUlJScmS4tG7dutDsASW3bt3i6tWrJCUlYWFhQceOHXMEtL6PMuBY7lJ42qT1Y6hWrRqCIHywfLoc6GzXgkGbtP4vUBRt1/9v6ByEOoo88fHxlCtXrrBlfBQ6rZpB01qVWYL379/PUfLCysqKqKgonj17lqsh9ebNGywsLChbtixhYWEa0wlQpUoV0tLS1DozP4bU1FSqVKkiizNT6VwNDw/PsWmWkpKCiYkJgiDk+rcotRYvXpzo6GiNaoW3tcLT09PzdAb7+PjQrVs3ihUrhre3N3Xr1pWOFUUHobW1NYIgcP/+/cKW8kGK4vXLDZ1WHUWB/fv34+zszMOHDxFFkXr16jF16lQ6d+5MYmIiAwYMwMfHR2VMsWLFGD58OEuWLJGltytAhw4dEASBCxcuqPw8MTGRKVOmcOzYMUC155QgCBgZGTFz5kwmTZoki04l8fHxbN++nVOnTnH//v0cPXTfp0GDBvTt25cRI0aobHRqGuW9XbFiRTZv3sw333wj22f/r7N//342bdqEnp4eXl5e0s9TU1OZMWMG+/fvJysrS2VM2bJlmTFjBhMnTpRbLjdu3OD06dN4e3sTHBws9UJ8F0NDQ2rVqkWbNm3o06ePxsvMv49yvrZu3ZodO3YUuUCF9wkODmbbtm1ER0ezbds2lWOHDh3ijz/+UAm009fXx9bWll9++YWmTZvKLZdr166xYsUKrl69SlpaGubm5nTr1o3Jkyfn2a+nMDa1U1NT8fLykkqM5raJbWVlhZ2dHe3atcPQ0FA2fUqNc+bMYe/evSgUCgBKlSqFo6Mj06dPJy4ujr59+3L79u0cz66KFSty+PBhmjRpIovWGzduMHDgQGJiYnJoadGiBQcOHMi1lKycNmJiYiIzZ87k6NGj0jU1NDRkzJgx/Prrrzx+/BgHBweio6Nz/B0NGjRg3759nxQc+6lcvXqV5cuXc+XKFWm9V2cPKB2X+vr6tGvXjpkzZ/LVV1/JphPe9k8fPny4yvMKoESJEkyYMCFHJZ93KVeuHHp6esTFxWlaJqBdWvNDYb9v6WzXgkebtGoj2mC7vktAQIDUj1ZZYvT9YBFLS0vs7OyoV69eoen8L+gchDpkY+nSpQX6+zSZUabTqhmKqtaxY8dy8OBBxo4dm0PjyJEjOXr0KFu3bqVfv35qx+/evZtJkybRtGlTLl26VCCacuPrr7/m0aNH7Nmzh+7du+d7/NmzZxk4cCB169bl2rVrGlD4Lw0aNCA0NFRtedZr167RpUsXBEHA19dX7UPU39+f1q1bY2pqSkBAgEa1AjRu3JinT59y7tw5lf6D7zN06FBOnDhBw4YNuXTpkrTJXtgvBuooippyQ6dVM2iTVh0fz6RJk9izZ0+ODQA9PT2cnZ1xdXXlwIEDFCtWjHr16lGxYkWCgoJ4/vw5giDQrVs3qbeGplE3BzMyMujWrRs3btxAFEWp11T58uVJSEjgxo0b3L17V+phu3LlSlm0Xr58mREjRvD69Wvp2pYrVw5TU1NKly5N8eLFSUtLIykpiYiICBITE4G3G4SVK1dm165dtGrVShat725cxMTEMHjwYBYtWlToWZfazpgxYzh06BCiKNKgQQO8vb2Bt3O2R48eXLt2DVEUqVKlCpaWlhgaGnL//n1evXqFIAgMGzaMVatWyaI1MjKS0aNHc+XKFUD95vX7KDezO3bsyKZNm2Tr9aicrwCff/45y5Yto3///rJ8dn5xdnbGycmJjIwMrK2tpTkA8PPPP7Nx40bpWhsYGFCsWDFSU1Ol/1+3bh0DBgyQTe/27duZPn062dnZORwrFSpU4MiRI7k6q+S0EbKzs1mxYgUbN26UPi+vOfvufHF0dOSnn37SuEZ425evW7duXL9+HVEU0dfXR09Pj4yMDARB4Oeff+bRo0ccO3YMKysrhg8fTtWqVQkNDWX79u0EBQVhbGzMtWvXNJ79EBkZScuWLXn9+jUmJiYMGTKEypUrc/fuXQ4fPkx6ejp169bl0qVLap2scn3/aWlpdOrUSXJcCIJA8eLFSU9PRxAEZs2ahZeXF1evXsXCwgIHBwcqVapEYGAgJ06cICUlhdq1a+Pl5fVJAbL5Zfny5SxZsoTs7GzgrSPd2toaU1NTjIyMMDAwID09ncTERCIiInjw4IFU7UZfX5+FCxfKFiySlpZGhw4d8Pf3RxAEWrVqRaVKlfDz8yMoKAhBEOjXrx9bt25VO17ONUCbtJ47dy5f5/fv3x9BEDh8+LDKuta5c+eClpYDne2qGbRJqzahTbYrwMGDB1mxYgVBQUHAx9kttWvXZvbs2fTq1UsOiQWGzkGoQzbefTH8GJTGY24/16RhoNOqGYqq1kePHtG2bVvS0tIYO3Yss2fPljIWAwMDsbW1pWzZsri6ulKrVi2VsdevX6dfv34kJCSwYsUKRo4cWSCacmPlypUsXLiQzz77jK1bt9KpU6ePHnvhwgVGjRrFmzdvmD9/Po6OjhpUCk5OTmzdupVGjRpx7Ngx6UEeGxtLnz59pM3fH3/8kXXr1uUYP378ePbv30/v3r3ZuXOnRrUCODo6smPHDpo2bcrJkydzNf5evXpFixYtePPmDf3792fLli1A0XTEFEVNuaHTqhm0SauOj+PEiRMMHToUQRAYNGgQvXv3pkyZMvj6+rJ06VLKlClDXFwcxsbGHDp0iAYNGqiMnTBhAikpKezcuZPevXtrXK+6Obhx40Zmz55N8eLFWb9+Pd99912OcW5ubgwfPpzU1FSOHDlCx44dNarz4cOHtG/fntTUVCwtLRk/fjwdOnTIUVngXUJDQ/Hw8GDz5s08evQIIyMjPD09sbS01KhW+Pe6BgcHM3XqVE6ePEnlypX55Zdf+PHHH/9nyjjKya5du5g8eTJ6enpMnjyZUaNGYWZmBsCGDRv4+eefKV26NMuXL2fgwIHSNc7Ozmbr1q3Mnj2b7OxsDhw4gL29vUa1xsXFYWtry4sXLzAwMMDBwYEOHTrQoEEDaRP73U3B8PBw/P398fDw4OzZsygUCr744gu8vLxk2exSztczZ84wfvx4QkND+eabb1i6dKks98vH4u3tTY8ePcjOzqZFixb89NNPUplGV1dXyfE3YMAApk2bRs2aNdHT0+PRo0csXryY06dPY2BgwJUrV1SqTGiKu3fv0r59e7KysujYsSNTpkyhcuXK3LlzhxUrVvDkyRM+++wzrl69Ks3ld5HLRsjOzubbb7/l0qVLiKKIiYkJ7dq1w9raGjMzsxyb2OHh4Tx48ABPT0/Cw8MRBIGuXbtqvH86/Pt8+vzzz1m9ejVdu3ZFEATc3d2ZNGkS8fHxiKJI3bp1uXjxoorDKiUlhXbt2vH48WOcnJyYO3euRrXOnj2bjRs3UqNGDS5evKiSKejn50evXr2IjY1l9OjR/PHHHznGy/X9r127ll9++YVy5cqxbNkyevXqhaGhITdv3mTkyJG8fPmSrKwsmjRpwunTp1Uymp4/f063bt148eIFv/32m8arCri5ufH9998Db0uwOjo6ftQaFRgYyNq1a9m9ezeCIHD06FE6dOigUa0A69atY+7cuZQtW5ajR4+qBLnu2LGD6dOnk5WVxerVqxk6dGiO8XK+J2iT1vzuW6lDEASNZzvqbFfNoU1atQVts13fDcg1NDSkWbNmH7Rbbt26RVpaGoIgMGrUKJYvX65xnQWFzkGoQzZ2795NWFgYK1euJCsri2LFilGnTh3Mzc0xMDAgNDSUgIAA0tPT0dPTo2fPnnlGiClrkOu06rQWBC4uLowePZrU1FRKlSqFnZ0dTZo0oVq1aty+fZu//vqLkiVL0rt3b+rVq0dGRgbXr1/n/PnzZGVl0b59e44fP65xQyEjIwN7e3tu3ryJIAjUqVOHjh07Ur9+fczMzKSHanp6OklJSbx8+VJ6qAYEBCCKIi1btuTMmTMaLy8XERFBq1atiIuLo2zZsrRo0QJBELh+/Trx8fG0b9+eFy9eEBgYyMyZMxk/fjxly5YlPj6etWvXShkjH8roKyiePXuGjY0NSUlJVKhQgZ49e1KnTh06d+6cw8g+d+4cAwYMIDs7m+bNmzN27FiGDRtW5Bwx2uQc0mnVDIWtdciQIf/5dwiCwK5du/67mA/wyy+//OffIQgCCxcuLAA1udOzZ0+8vLyYNGkSv/32m8ox5camIAhs2rRJbRbLmjVrmDdvHt988w3Hjx/XqFZQPwft7Oy4d+8eCxYsYMqUKbmOVf49nTt35vDhwxrVOXz4cI4dO0bHjh3Zv39/rqWm1ZGZmcmAAQM4f/48/fv3zzX6vSB5/7oeO3YMJycn4uLi+PLLL5k2bRrffvttkdjAyG8kfm5oOhJfOS/VBVEpj/35558MHz5c7fhly5axZMkSOnToIJXO1RQ///wzGzZsoEaNGhw5ciRHAFtehISE0LdvX54+fcpPP/2k8TULVOdrcnIyc+fOZefOnRQrVowff/wRR0fHPDc05aJXr15cvnyZb7/9lm3btqncP8q1d9y4cfz+++9qxyurTHz//fds3rxZ43qV61bbtm05deqUyrGEhAQcHBy4d++e2uMgn42gXMtLlSrFypUr+f777z+qT6Ioihw+fBhHR0dSUlJYvnw5o0aN0qhW5b2+YcMGBg0apHJs3759jB8/HkEQOHTokNo1SelIrl+/Pr6+vhrV2qRJE0JCQnINSjh//jz9+vVDT0+PK1euYG1trXJcru9feU3XrFmTwy48fvy49A514sQJ2rVrl2O88hw5qvV0794db29vJk+ezK+//prv8QsWLGDVqlW53nMFTdu2bbl79y5//PEHo0ePznFcafOVKVOG27dv5+jzJ+d7gjZpVa7lSj70fAoNDUUQhBxlcP38/DSiT4nOdtUc2qRVW+xsbbJdlc97fX19ZsyYwbhx4z6q7VVCQgKbN29m6dKlZGVl5VmJrqihcxDqkI3Xr19jY2NDeHg4w4YNY9q0aZibm6ucExUVxYoVK9i8eTNNmzbF3d09Xw85nVad1v9CYGAgv/32Gy4uLmRnZ+d42L+f0SiKIqVKlWLcuHH8/PPPsvVzSktLY968eezatUsqzfIhlFEvw4cPZ8GCBZQoUUIGpXDnzh0GDx4slV1R0rx5c44ePcqjR4/o2bMnaWlp6OnpYWRkRGJiIqIoIooiTk5OBbJp/7F4e3szbNgwqeehIAjs2LGDPn365Dj38OHDTJw4UfoO5MjCzS+F7RzKDzqtmqGwtVpaWhIVFZVj7cwPculX9k39VORaA6pXr86bN2+4d+8eFhYWKscCAwNp1qwZgiDw8OFDTE1Nc4x/+vQpjRo1okKFCoSEhGhUK6ifg6ampqSkpBAQEJBnf6yoqCgsLS1l0arsOXzz5s1PiqJ+/PgxzZs3x9jYmCdPnmhAoSrqrmtsbCzLli1j165dKBQKqlatytChQ/nhhx8KteebtkTiK/s8BwYGUqlSJZVjJiYmpKamEhISkms/r1evXmFlZcXnn3/Os2fPNKq1YcOGPH/+nLNnz9K6det8j1f2VP7iiy+4e/duwQt8D3Xz1cvLizlz5uDn54eBgQF9+vRhxIgRsgSF5UbVqlVJTEzk9u3b1KhRQ+VYtWrVSEhIUNuzXIlyDZarPP6XX35JZGQkHh4eanvzBAYG0rp1axQKBbt376ZHjx4qx+WyEWxsbPD392fjxo0MHDgw3+OVG3UNGzaUypJpCuXzKTg4OEeJ0NjYWGrUqCFllagrIRodHU2tWrUoXbo04eHhGtVauXJlFAoFz54947PPPlN7zo8//sjp06fVOqzk+v7NzMxITk7myZMnOZw+L1++pG7dunleU+XaWrZsWcLCwjSq1cLCgvj4eLXPgY9Babd89tlnsvT2VF7b3Gw+URRp06YNfn5+DBkyhDVr1qgcl/M9QZu0wtt3fScnJxISEujYsSMbNmzIMX8LS5sSne2q0/qu1v+CHHa2NtmuHTp04NatWyxatOiTSkavX7+eOXPm0KJFC86fP68BhQWPzkGoQzZmzZrFpk2b+Omnn3JEvL/PggULWL16NbNmzdJoT7zc0GnVDNqiNSYmhvPnz3P37l2CgoKIiYkhOTmZrKwsSpcuTYUKFahVqxYtW7akU6dOHxVJogmio6NxdXWVmuW+ePGC5ORk0tPTVZrlWllZYWtrS9euXWWt161EoVBw/vx57t+/j56eHg0aNKBz587o6+sDb8u0Tp06FX9/f2lMtWrVmDVrVo7IXTlITk7myJEjeHp6EhISwty5c3Mt5RoYGMiqVatwc3Pj9evXRc5pVNjOofzg4+MDvN1EKurotH48oiji7u7O7Nmzefr0KYIgMHz48HxvusyePVtDCv8lISGBAwcOsHTpUul+7tq1a77XeE1m4gNUqFCBrKwsIiIicmTZp6amUqVKlTzv+7S0NIyNjTEwMCAmJkajWiFvB2F0dDQGBga5jpVTq3Kj9dWrV58URJOenk7lypUxNDTk1atXGlCoSl7r+8uXL1myZAkHDhwgOzsbPT09WrZsSffu3Wnfvj1WVlYa1/cu58+fZ8+ePZw+fVr6mYmJSZ7fvTo0HYmvdL6/ePFCpcQd/Os4ymvOKhQKKlWqRIkSJYiKitKo1v+l+Xrs2DGWLFki9aCytLSkT58+9OjRQ22Pak2idASru67Gxsakp6cTGxsr2bDvk5mZSYUKFShevLgUbKZJKlasSGZmptrngRJlRlPNmjW5ceOGSkCjXHai8rq+fPmS0qVL53t8UlKSVNJL0043pdanT5/y+eefqxyLi4ujevXqCILA8+fP1doH8fHxVKtWTZZ7y9zcnKSkJMLCwihTpozac54/f85XX32FQqHI0cNeru9fGYClzpGZkZFBxYoV89SRmJiIubm5LPeV0oml7jnwMSjnqpGRES9fvtSAQlWU61JUVFSuQdXKTfVixYrh7e2tUv5YzndFbdKq5OXLl4wfPx5PT08qVKjAn3/+qbavWGG9c/8v2QJFzXbVJq3aYmdr03xV2v15BeDkhdJekCOwpaDQOQh1yEaDBg0IDQ3NNWLoXSIiIvjyyy+xtLTk1q1bMin8F51WzVBUtebW61CHvISGhhIZGUnFihVzRG1rA2FhYbx8+ZKvv/66sKVIKDM3i0LZLh3/vwkODqZZs2aIosjff//Nl19+WdiScuX27du0a9cOQRCKpNZatWoRExODl5cXDRs2zHF8zpw5CILAokWL1I5XRgsXZgZh586duX79OlevXs2zT9fdu3exs7OjSpUqPH78WKM6GzduzNOnTzl9+jRt2rTJ93hvb28cHByoWbMmt2/f1oBCVT5mM+rp06fs2LGDgwcPqmTyVq5cmaZNm9KoUSNmzpypca1K9u7dy4QJE4rsvWVvb8+1a9fYvn07ffv2VTnWqVMnbty4waVLl2jSpIna8devX6dTp05YWFhw//59jWpVZo5dv36d2rVr53v8kydP+OqrrzAxMeHRo0caUKjKh+arsnfj1q1buXPnjjRXK1WqhK2trTRfPyXiPD+0atWKhw8f4u7unsOea9GiBY8fP+bOnTt88cUXascHBwfTpEkT2bIxlE5tdZlZSpKSkmjSpAlRUVH8/PPPzJgxQzom16b2F198QVxcHI8ePaJKlSr5Hq/MypIjO1eZ7bht2za+/fZblWNHjx5lxIgRCIKQawaE8llQq1Yt/vnnH41qVZbu3LVrl1qnhZLFixfzxx9/ULFiRf7++28pSEuu71+5B3D8+HHat2+f47i7uzsAXbp0UTv+xo0bdOzYETMzMx4+fKhRrXmVQ/0YlM+5xo0b4+npWfAC30Npu3yoJYeyZGbDhg25dOmSFCggp2NLm7S+z6ZNm/j1119JS0vj22+/ZcWKFSpOg8LSprNddVrfpajb2dpkuyqrRqgLFvoY3rx5g4WFBeXKlctRTa2o8uHC7zp0FBAREREAH5XBpCwtUViedp1WzVBUtX7xxReMHTuW06dPk5ycrPHP06GeatWq0bx5c610DsLbKKOi5ByEt9e0qDkHExMTuXv3Li4uLhw4cIAdO3awb98+Tp48yc2bN7Ui2zE6OpoDBw6wevVq9u7dW6hGX3Z2Nk+fPlV77MaNGyxfvhxHR0dmzpzJ1q1bC239r1mzJk2bNi2Uz84vTZo0ydGnpyihLCO3ZMkStccXL16cq3MQYPv27cDbDTs5OXz4MPfv3yc9PZ3Ro0cjimKufwO8nduLFi1CEARatmypcX09evRAFEUmTJiQ7w3Ihw8fSi/kPXv21JDC/PPFF1/w22+/8ejRI/bu3UunTp0oUaIEr169wtXVNdc+aprihx9+yFFavigxdOhQRFFk+vTp3LlzR+XYyJEjEUWRxYsXqx2rUCj45ZdfEAQh16oDBUmbNm0QRZEZM2aQmpqar7Hp6elMnz4dQRBo27atZgTmEz09PQYNGoSnpyfXrl1j9OjRfPbZZ0RFRXHs2DHmzJmDg4ODxnX06dMHURSZOXMmCQkJKsf69u2LKIp59mlatWqVbGsWID2r9u/fn+s5RkZGLF68GFEU+eOPP7h+/bos2t5FGcyyatWqTxq/evVqgFyd8wWJcg7MmjVLpd/d5cuXpWoGyrXg/ZLp2dnZ/PbbbwiCwDfffKNxrV27dpXWrLy+1+nTp1O3bl1iYmLo3bu3LNmt72JraytdU3XVALp06ZKrcxDe2juCIMjynvXjjz9Ka+u2bdvIzMz8qHGZmZls374dJycnBEEokB7cH0Pbtm0RRZHZs2fnWLPeZdmyZXz++efcv3+f8ePHy6LtfbRJ6/uMGzeOK1eu0LBhQ44cOUKrVq003g/zY9DZroVLUdNa1O1sbbJd69SpA8COHTs+afyuXbsAZK+E8V/QZRDqkA1lfewPRQzBvxG4ckW3v49Oq2Yoqlo3btyIu7s7V69eRU9Pj9atW9OtWzfs7e0xMzPT6GfrKJq8efMGURRzRAtlZGRw4sQJ/P39SUxMxMzMjPbt28uyYaGO2NhYnjx5kmMjKisrixMnTuDl5UV4eDjFixenVq1aODg4FEpvn/j4eLZv386pU6e4f//+B3vQNWjQgL59+zJixIhPKu/zX7h58yZbt27F398fQRBo0KABjo6OUqmQdevWsWjRItLT06UxgiDwww8/sGLFCtn6e2ZkZLBy5Uq2bt2KmZmZSk+eqKgoRo4cKf3s3SxpfX19RowYweLFi/NdduS/MmPGDLZs2VIkIxrfx9HRkZ07dxZJrZcvX6ZXr14IgkDjxo3p27cv1atX/+Dm+fPnz3F2dmbVqlWIophrf9WCRlmCTTkH9fT0+OKLLwgJCUEURYYOHSpt/sLb+Xrp0iWWL1/OtWvX0NPTw93dXeNrV2JiIm3atCEkJIRixYrRsWNHOnTogLW1NaamphgZGVG8eHHS09NJSkoiPDwcPz8/PDw88PDwIDMzE0tLS7y8vD6phF5++dRo9fT0dK5du8alS5fw9PTUeD+v9xk9ejSHDx8ukvcWwIgRIzh69CgGBgb06tWLXr160aRJE0xNTZk6dSo7duzAzs6O6dOnU69ePTIyMrh+/Tp//PEH9+/f57PPPuP69euflCWVHwIDA2nbti3JyclUrVqVMWPG0LFjxzwjsh89eoSHhwdbtmzh+fPnlC1bFi8vL1kCsz5lviqv7eXLl7l06RL37t3j9evXmhPJ27LG7dq14+HDh1hYWDBt2jS6d+9O+fLlSU9Pp0uXLty5c4fZs2czefJkDA0Ngbf22KJFi9ixYwf6+vqcP39ebU/AgkbZm8/AwIBZs2YxdOjQXAMxhwwZwsmTJ/nss8/Yvn07HTp0kC3r5eLFi1JWbq9evZgyZQqNGjX64Li7d++yevVqTp48iSAInDx5Ejs7O41qTUtLo2PHjty/fx9BEChdujSCIJCUlAS8tQ/8/f25cOECdnZ2jB07FnNzc8LCwtiwYQM+Pj4YGRlx7do1jQfpJSYmYmdnR3BwMIIgYGVlRd26dZk0aVKOoKzAwEA6d+7M69evKVu2LH379mXHjh2yfP+BgYHY2dmRkpJCyZIlsbOzo3r16ixdujTXMdevXycoKIg9e/Zw7do1We+rH374ARcXFwRB4PPPP8fOzo769etjampKmTJlMDAwQKFQkJiYSHh4OP7+/nh5eUnvj71795Y2hzXNs2fPsLGxISkpiQoVKtCzZ0/q1KlD586dc8y/c+fOMWDAALKzs2nevDljx45l2LBhsmW+aZPW3MjKyuL333/nzz//JDs7mxEjRrBo0aIPlvfXFDrbVXNok9Z3Kcp2tjbZrsqKAXp6ekyaNIlJkyZ9VIuU6Oho1q9fz7p168jOzv5ghn9RQucg1CEbI0eO5MiRIzRr1gwXFxdKlSql9rzU1FQcHBz4559/sLe358CBAzIr1WnVFEVda0JCAufPn8fNzY0LFy6QkJCAtbU1Xbp0oWvXrjRu3FgWHToKh6ysLJYvX46zs7OU7WpiYoKTkxMjRowgMjISBwcHgoKCAFWnS5cuXdi8ebNs/Sjj4+OZPXs2hw8fpm7duiqG55MnTxg0aBCBgYGSTkBF619//fVJtdQ/hcuXLzNixAhev34taSlXrhympqaULl2a4sWLk5aWRlJSEhERESQmJkp6K1euzK5du2jVqpUsWjds2MDcuXMRRVHFiVm2bFlOnDiBn58fU6ZMAd46MZUbQn5+fgiCQMeOHTly5IjGdWZmZtK3b1+8vLwQRZGmTZtKUaxJSUm0b9+eJ0+eIIoizZo1o3bt2hgaGnL79m2pdFthPAfu3buHr68vAwYM+KRSHXJy5coVXF1dmTZtWr77JcrB2rVrWbBgAVlZWQiC8MHG8soyKfB2Tfjuu+/YsmWLLFp37NhBUFCQ9O/58+cqEfl169bl2rVr0v97eHjw7bffSmvskiVLZIsgj42NZcKECbi5uQH/rpt5oVwrHBwcWLt2rVQBQdNoU4/Zd9m9ezdbtmxh7969VK9evbDl5ECZZbV69WpSUlKkOVCsWDFKlSqVa9aDKIpYWFiwd+9e2bJzr127xtChQ4mMjJR0GhgYYGJigpGRkbSJnZSURGRkJBkZGZJWExMTnJ2dZQsaKoj5Gh8fL4udFRsby7Bhw/Dy8pLWVwsLCywsLADw9PREEAQMDQ2pUaMGCoWCkJAQsrKyKFasGKtXr+bHH3/UuE54+10OHDgQV1dXaQ5UqFCBDRs25MjISkpKwsHBQbIDLC0tefLkiWzryIYNG/jll1/Izs6WdNavX1/q1/b+Jra/vz+xsbGIooi+vj5Llixh7NixGtcJb+eao6MjJ06ckPQWK1aMCRMmsHDhQiIiIrC3t5d6KysRRRFDQ0N27txJ165dZdEaGRnJpEmTOH/+PPD2uZVbANDDhw8ZNGgQISEhCIIgPWfl+P59fHwYPXq01JfvQ5+r7FUsiiLFihVjxYoVDBs2TOM6laxfv541a9ZI/WTzsgeUdoCxsTGOjo6MGzdOFo1KvL29GTZsmJQZmtccOHz4MBMnTiQ9PV32OaBtWvPi1q1bjB49mpCQECnorbC06WxXzaBNWt+lqNvZ2mS7zpo1i02bNiEIAvr6+jRo0CCH8/3dYBE/Pz/8/PzIyspCFEUmTZqUZ1WfoobOQahDNp48eULr1q3JyMjA0tKSmTNn0qFDB2mTOj4+Hg8PD5YtW8bjx48RBAE3NzfZSrTotOq0vktWVhY+Pj64u7vj5ubG06dPMTExwd7eHnt7e9q2bZtrc20d2kd2djb9+vXj4sWLObLbBEFg5cqVXLhwATc3N8qVK0ebNm2oVKkSgYGB+Pr6IooizZs3x83NDX19fY1qTUpKolOnTjx8+BBRFOnQoQPHjh0DICYmBhsbGyIiIjAwMKB79+7Url2bkiVLcvv2bc6cOUNWVhZfffUVrq6uGs8ge/jwIe3btyc1NRVLS0vGjx9Phw4d8oyoDg0NxcPDg82bN/Po0SOMjIzw9PTE0tJSo1qvXbuGvb09oijSqVMnunfvjr6+Pi4uLri5uWFqakpSUhLZ2dns379fJYL90qVLDBo0iNTUVLU9awqa1atXM3/+fEqVKsXixYsZOHCglMWwdOlSfv/9dypVqsTOnTuxtbVVGevm5sbw4cNJTU3lr7/+4vvvv9eoVh2aQ1nO5p9//iEqKirPXkcmJiakpKRQp04dxo0bJ1vpK3VkZWXx9OlTyWGYnp7OtGnTpOMeHh4MGDCATp06MXXq1EIpTevn58eJEyfw8fEhMDBQbdZS+fLlsbKywsbGht69e1O/fn1ZNWrrxoW2EBsby759+zh//jz37t3L1TFYunRpmjdvTq9evRg4cKDstmFKSgq7du3i5MmT3Lp1i6ysrFzPLVasGM2aNaN3794MGTKEkiVLyqZTG+eru7s727dvx9vb+4OlsIyMjOjSpQvTp0+XPWI/Ozub9evXs3HjRinAbefOnWo33JOSknBycuLQoUOS40vO7+XOnTssX76cCxcuoFAoVI4pHQDvUqJECTp16oSTk9NHZRwWNLGxsTx8+BA9PT2+/PJLlU302NhYli1bhpubm9RD3c7OjqlTp0pVJ+QkMDAQLy8vQkJC6NevX66BrRkZGRw9ehRXV1fu3bvHy5cviY2NlUVjZmYmHh4e/PPPP0RHR6tUD3ifatWqUblyZdq2bcvo0aML5ZoqFAp8fX3x9vYmKCiIsLAwkpOTSU9Pp0SJEpQuXZqqVatiaWmJra0trVu3lr06h5Lk5GSOHDmCp6cnISEhzJ07N9dy14GBgaxatQo3Nzdev34t+9qsTVrzIjU1lZ9//lkqQVjY2nS2a8GiTVq1DW2xXQFcXFxYtmwZfn5+0s/UOeHftV8aNmzIrFmzZAsUKih0DkIdsuLu7s6IESNISkqSbiojIyMEQZCyRpRRgr///jtjxozRadVpLTSt7xIQEICrqyvu7u7cunWLkiVL0q5dO7p27Urnzp0/qq+ijqLLzp07mTJlCsWLF8fJyYk+ffpgZGSEr68vTk5OKBQKUlJSsLS05NSpU5iamkpjb968Sf/+/YmLi/vkhvb54ddff+XPP/+kYsWKbN68mQ4dOkjHfv75ZzZs2ECNGjU4cuQItWrVUhl77949evfuzevXr1m2bJnG76/hw4dz7NgxOnbsyP79+/O1cZqZmcmAAQM4f/48/fv3z7PnT0EwYMAAXF1dGTJkCGvXrlU5NnnyZHbt2oUgCMyfPx9HR8cc4//44w8WL15Mu3btOHnypEa1tmjRgsePH7N69WqGDh2qcuzrr7/m0aNHbN++XSrn9T5bt27FycmJ1q1b4+rqqlGtOooG169fp3r16hgbGxe2lA+SnJyMvr6+5PQuCqSmpubYFJT7BfV9fHx8ALCxsSlUHf9fiIqKIjo6muTkZLKzsylVqhQVKlQoUqXo09LSePr0aa6b2DVq1JCtDPb7KHuIKXu4aRPp6ek8evSIoKAgoqOjSUlJISsrS5oDlpaWWFtbF4nAwcePHxMSEkL9+vWpWrVqrueFhobi5uYmOYhOnTolo8q3m4PXr18nMDCQFy9ekJSUhEKhoHjx4hgZGWFubo6VlRXNmzfPteKMjv9t3q3UokNzhIWF8fLlS1n6O/5XiqrWv//+m+DgYAAGDRpUyGr+RWe7/je0Sas2U5Rt13cJDg6WnO952S02NjaylO7XBDoHoQ7ZefHiBStXruTUqVM5otVKlixJhw4dmDp1aqH19HoXnVbNoE1a1RETE4Obmxtubm54enqSlpZG06ZN6datG99++63GGwMXhANKEARZeiNoi9bOnTtz/fp1FixYIJWQVLJnzx4mTpyIIAjs3btXbZ+vXbt2MXnyZFkcLo0aNeLZs2dq65krjx0+fDjXSMzDhw8zatQomjRpwuXLlzWqVdl39ObNm5+UAfj48WOaN2+OsbExT5480YDCf6lZsyaxsbH8888/1KxZU+VYcHAwTZo0QRAEbt++rdboU55Tvnx5nj59qlGtlStXRqFQ8PTp0xylOo2NjUlPTycsLIwyZcqoHf/69Wu++OILypUrR2hoqEa16tChQ4cOHTp0aBO+vr4YGhoWSga7JsjKyuL169cYGBjI1mJAhw4dOnTo0KE96ByEOgqV0NBQoqOjyczMpHz58tSoUUPj5fk+FZ1WzaBNWtWRnp7O5cuXcXNz49y5cwwdOpRZs2Zp9DMtLS2JiorK0fMiP8hVLkFbtCr7cz148CBHNsDz589p0KABgiDw5MkTKleunGP8ixcvqFevHp999hnPnz/XqNZKlSqRkZHBixcvMDIyUjmmdBxFRkbmmn2TlJQk9XtR9gHRFEo9r169+qTIr/T0dCpXroyhoSGvXr3SgMJ/qVixIpmZmWqvXWpqqtR8Prdrm5aWhrGxMQYGBsTExGhUq9KZqc5BaGFhQXx8fJ7XXKm1ZMmSREZGalTrx+Lg4IAgCLi4uBS2lA8yfvx4BEFgw4YNhS3lg+i06tAmXr58yYMHD6TnVNOmTSlWrFhhy1Lh9evXeHl5ERQURFpaGuXLl6dJkyZ8/fXXRSLb5fXr11IUdkpKihSFbW5urtZ+kYulS5dSqlQpRo4cqcsIkxmFQsHt27cJDw+nePHi1KpVS/YyqB+DMmugKKAsLdevXz/WrFlTpOfsmzdvOHDgAOHh4fz2228qx65evcry5cu5evUq6enpwNvejw4ODkydOlXqqyknISEhrFu3jqtXr5KcnIyFhQXdunVj2LBheWY32djYoKenp9J3XQ4CAgLw9vYmMDAw17XV0tISOzs76tWrJ6u294mLi0MQBLVO4LNnz+Lq6iqVw23bti39+vUrlGdsVlYWp06dwtfXV2UOfKh/7+zZs6Xe1HLy5s0bRFHM8c6VkZHBiRMn8Pf3JzExETMzM9q3b1/oQe4BAQEEBgYSGhpKcnIyqampUpaTmZkZVlZWWFtbF6pGgFevXnHt2jVpDnz11VcffAYoA7HlLt2oTVo/hsJaT3OjqNqu/9/QOQh1FAmUqbnagE6rZtAmrXkRHx9PuXLlNPoZoiji7u7O7Nmzefr0KYIgMHz4cCpVqpSv3yNHmSdt0ap0DqlzuimdVHk5KlNSUjAxMZHFOVS7dm1evXrF48ePc5QLrFGjBq9fv+bly5eULl1a7fjk5GRMTU0pXbo04eHhGtXauHFjnj59yunTp2nTpk2+x3t7e+Pg4EDNmjW5ffu2BhT+S926dQkPD8fLy4uGDRuqHLt37x5t2rRBEIRcsyEDAwNp1qwZlSpVIigoSKNae/fuzeXLl1m5ciUjRoxQOdazZ0+8vLw4c+ZMriVRLl68SJ8+fbC0tOTWrVsa1fqxaFOfB51WzaBNWnXkH19fX3bt2iX1z61Xrx4TJ06kYcOGZGZm8tNPP3Hw4EGpLxq8nRPTp09n4sSJsukcPnw4giCwfft2lZ9nZWWxePFiNm7cSFpaWo5x1apV47fffqNnz55ySQXe9p87fvw4p0+fxtvbm7i4uFzPLVu2LG3atKFv37706tVLVoem8v62tLTE2dmZunXryvbZ/+v4+PiwadMmEhISVIJsRFFkxYoVrFu3LkcPzZo1a7JgwQK6d+8ut1xevnzJ2bNnpVJdyk1BZQBhyZIlpU3sNm3a0KNHD5XS/nLw7rtczZo12bBhAy1btpRVw8dw/vx5xowZQ1xcHNbW1nh7e0vHNmzYwNy5cxFFUW1/9TJlyrB7927atWsnm15XV1dGjBhBamqqiiZBEKhRowbHjx+nevXqasfKbSMcPHiQFStWSDZ9XgGuyrW0du3azJ49O0eFF00iiiJr165l8+bN0ntd1apVmTt3Lt999x1paWkMHToUd3f3HNfcysqKw4cP53rNNUFISAjff/+9VBnm3VKyffv2ZePGjbk6XuScA1lZWSxfvhxnZ2ept6uJiQlOTk6MGDGCyMhIHBwcVOaH8u/o0qULmzdv1vie0LuEhISwdu1aXFxcPqqnaPny5enVqxdTpkyhWrVqMij8l/T0dKZPn87evXtVbL5KlSoxZ86cHO0z3qVcuXLo6enlaesUJNqkNT8U9juXttiuSlJTU/Hy8lKxW5KSkkhNTZWcmUq7xc7Ojnbt2hWpVhkfi85BqEN2MjMz2bFjB2fOnOHRo0fExMQgiiJxcXEEBgayfft2xowZwxdffFHYUnVa/x9rXbp0aYH+Pk1kFQYHB9OsWTNEUeTvv/8uktHASoq61jp16hAREcG5c+do0aJFjuNbtmwBYPTo0WrH379/H1tbW1lKYf7444+4uLgwZ84cpk+frnJs4MCBuLq6cuDAAezt7dWOP3nyJEOGDKF+/fr4+vpqVOv8+fNZvXo11apV49ChQ/naEHz48CHff/89oaGhODo6Mn/+fA0qhbFjx3LgwAHatm3LoUOHJKMuPT2d/v374+npiSAI/PTTTyxcuDDH+Llz57Ju3Trs7e05ePCgRrWeO3eO/v37U6pUKbZt20a3bt2kYxcuXODbb7+ladOmuLq65jBOX79+TZcuXXjy5Iks1/VjKewXlfyg06oZtEmrjvyxbNkyfv/9d0B1k7VkyZIcO3aMs2fPSpmjn3/+ORUrVuT58+coFAoEQWDEiBGsXLlSFq3q5qEoivz444+cOXMGURQpV64czZo1o0KFCiQkJHD79m2pWkJufWo1wYMHDxgyZAhBQUEq17V06dKULl2a4sWLk5aWJmUQKBEEgbp16+Ls7PxJ5b8/BeV1NTQ0JDs7mxkzZuDo6KhVVUOKIosWLWLFihWIokiDBg1UHERDhgzh1KlTUm93c3NzDA0NCQ4OJjMzE0EQ+OWXX5g2bZosWpOTk5k5cyYHDx4kMzPzoyqKCIKAgYEBgwcPZvHixbJtuCnn68aNG5k1axaJiYkMHTqUuXPnUqFCBVk0fIj79+/ToUMH0tPTqV69OhMnTmTUqFEAXLt2DXt7e0RRxMbGBkdHR2rXrk3JkiW5desWy5cv59atW5QpU4arV6/K4iAICgrCxsaG1NRUrK2tGTduHJUrV+bu3bts3ryZ6OhozMzMuHr1qtoMODlthEmTJrFnzx5EUcTQ0JBmzZphbW2NmZmZytqalJREeHg4Dx484NatW6SlpSEIAqNGjWL58uUa1wmq9/m7CILAunXruH//Plu2bKFChQp89913mJubExYWxqFDh3j9+jU1a9bE29s718DSgiQ+Ph5bW1ueP39OqVKl6NWrlzQHlO9Ztra2nDp1Cj09vRzj5ZoD2dnZ9OvXj4sXL6q9ritXruTChQu4ublRrlw52rRpQ6VKlQgMDMTX1xdRFGnevDlubm6yPOP279+Po6Mj6enpiKJIiRIlsLKykgKCixcvTnp6OomJiURERBAYGCjZVyVLlmTDhg306dNH4zrh7bXt3bs3Xl5eiKJItWrVpODa+Ph4BEHI8/1UznVAm7Q+evQoX+e3aNECQRC4fv26yhyXY49Om2zX7OxsVqxYwcaNG6Xv8WOCRT7//HMcHR356aef5JBZYOgchDpkJTg4mD59+vD8+fMcEUxv3rzhzp07tG3bllKlSrF161a1vb50WnVa5UD5QP9Ycmukrvy5pgyDDh06cOvWrSLpdHufoqx16NChnDhxgubNm+Pi4pLvDYgRI0Zw7Ngx7O3tOXDggIZUvuX69evY29sjCAK//fYbY8eOlV6ibt26RadOnahRowbnzp3LsYkREhJCt27diIiIYN68eUydOlWjWhMTE2nTpg0hISEUK1aMjh070qFDB6ytrTE1NcXIyEh6aVG+ZPv5+eHh4YGHhweZmZlYWlri5eWl8RfXwMBA2rRpQ2pqKhYWFnTo0AFBEPDw8ODZs2c0bNiQqKgoYmJiWLNmDQMHDpTG7t69G0dHR7Kysjh48CBdunTRqFb41/kqCALNmzenZ8+eNG3alGrVqrFlyxZWrVpF3bp1mThxIvXr10ehUHD9+nU2btzIy5cvqVq1KlevXqVs2bIa1/oxaJNzSKdVM2iTVh0fz+XLl6VsCjs7O3r16oWRkRFXr15l165dWFhYEBERQcmSJdm8ebO0fmZmZrJhwwYWLlxIVlYWx48fp3379hrXq24e7tu3j/Hjx6Onp8fs2bOZPHmySoZDVlYW27ZtY/bs2WRnZ3P+/HmaN2+uUZ1hYWHY2toSFxdH+fLlGTJkiPR8VZe1EBcXx4MHD/Dw8GDPnj3ExMRQqVIlfHx8qFKlika1wr/X9ebNm4wdO5Zbt25Rr149lixZQtu2bTX++f+LnD59mh9//BGAPn36MGHCBJo1awb8O2f19fVxcnJiypQpUpnM+Ph4/vjjD9avX48gCLi7u/P1119rVGtaWhqdOnXi/v37iKJIs2bN6NChAw0aNJDsQQMDA5VNbH9/fy5evMjNmzcRBIGmTZvi5uYmS8WZd9eB8PBwJk2ahIeHB+XKlWPq1KmMGjVKFodKXvzwww+4uLjQtm1bDh48qFKec8CAAbi6utKvXz+2bduWY2xWVha9e/fmypUrDBs2jFWrVmlc76RJk9i9ezeNGjXi/PnzKmvoixcv6Nq1K6GhofTp04cdO3bkGC+XjfDuvTNjxgzGjRv3UZlgCQkJbN68maVLl5KVlcXWrVvp16+fLFoNDQ2ZM2cODg4O6Ovr4+LiwqJFi8jOziYjI4OqVaty8eJFlQo+r169on379rx8+ZJff/2VyZMna1QrwOLFi/njjz8wNjbm3LlzKsHgHh4eDB48mJSUFLVBsCDfHNi5cydTpkyhePHiODk50adPH4yMjPD19cXJyQmFQkFKSgqWlpacOnVKJcP55s2b9O/fn7i4ONasWcOQIUM0qvXvv/+ma9euZGVlYWtry5QpU2jTpk2e66RCoeDKlSusW7cOT09PDAwMcHd3l54fmsTZ2ZmffvqJEiVKsGnTJvr27Qu8zdBatmwZq1atQhAE9u3bpxIAq0TOdwVt0prfvUt1CIKg8WxHbbJds7Oz+fbbb7l06RKiKGJiYkK7du0+GCzi6elJeHg4giDQtWtX9u/fr1GdBYnOQahDNuLj42ndujVhYWHUrFmT6dOn07RpU7766itp4UxISMDR0ZGjR49iaGiIr68vtWrV0mnVaZVd6+7duwkLC2PlypVkZWVRrFgx6tSpg7m5OQYGBoSGhhIQEEB6ejp6enr07Nkzz74JmzZt0ojOGTNmsGXLliLpdHufoqz19u3bdOzYkaysLExNTXFwcMDCwoIJEybkOiY8PJzg4GCcnZ05cuQIgiDItoG5ZcsWZs6ciSiKmJub061bN5o0aYKFhQVnz55l7dq1VK5cmeHDh6s4h/bv309iYiINGjTg4sWLsmyyxMbGMmHCBNzc3AA+ynhVBg84ODiwdu1a2aK1z58/z4gRI0hISJB0iqJIjRo1OHPmDPfv32fgwIGIokj58uUxNTXl5cuXxMXFIYoiAwcO1Ni9ro4DBw6wcOFCyQj9GJRRrTt37sTc3FzDCj8ebXIO6bRqhqKg9ZdffvnPv0MQBLVZxgXN1q1bC+T3KDNONMX333+Pm5sbAwYM4K+//lI5tmTJEpYtW4YgCCxdupSxY8fmGK8MhujevTt79+7VqFZQPw+7dOnC33//nWsGuRLl39O7d2927dqlUZ0//fQTzs7ONG3alCNHjuTrOfnmzRv69OnD7du3ZXMOvHtds7OzWbNmDb///jsKhYJvvvmGGTNmqK3gUBjkNxI/NzRt63bu3Jnr168zbtw4KUNXSadOnbhx40aeGYLTp09ny5Yt9OjRgz179mhU6++//87SpUupWLEizs7OuZZAV8e1a9cYPHgw0dHRuToOChp168DevXtZuHAhr1694vPPP2fkyJEMHTq00Gyp6tWr8+bNG3x9fXP0vlO2HMitLD7A3bt3sbOzw8LCgvv372tcr7W1NWFhYbi4uGBra5vj+K1bt+jYsSOiKKotky+XjaAMaF20aNEnlbdev349c+bMoUWLFpw/f14DCv9FuQao07phwwZ+/vlnqWS20rnxLgcPHmTMmDE0adKEy5cva1QrQMuWLQkICGDz5s189913OY4rHZ7Fixfnxo0bOapJyTUHlNd1wYIFTJkyReXYnj17mDhxIoIgsHfvXrXB7Lt27WLy5Mm0bt1a6kOnKb777jvc3d0/+R103Lhx7N+/n27dusniyFDaU7Nnz2bmzJk5js+ZM4f169dTuXJlbt++TZkyZVSOy/muoE1aO3bsyI0bN/7z74mPjy8ANbmjTbbrxo0bmT17NqVKlWLlypV8//33ajOb30cURQ4fPoyjoyMpKSksX75c4+9aBYXOQahDNpYtW8aSJUto2LAhZ8+elRZQdQunstTbsGHDWL16tU6rTqvsWl+/fo2NjQ3h4eEMGzaMadOm5XgBjIqKYsWKFWzevJmmTZvi7u4uex/Fe/fu4evry4ABA3I0zi5qFHWtR48eZfLkySQlJQF80KAzMzNT6Zni5ORUIJvLH4u3tze//PILd+7cAT7seFNms/bt25dVq1bJnjnm5+fHiRMnpNrtr1+/znFO+fLlsbKywsbGht69e1O/fn1ZNcJbh+bBgwfx8/NDT08Pa2trBg0aJF2vU6dOMW3aNKKjo6UxpUqVYtKkScyePVv2uvgKhQI3NzfOnTvH3bt3CQ4OztEfq3jx4nzxxRe0bNmSnj17yuLEzi9FwTn0sei0aoaioLVSpUpkZGR88nhNVw14l4KIFgY0rrVWrVrExMSo3ah++PAhLVu2RBAE7t27h4WFRY7xyv6ucpTwBvXzsGrVqiQmJuaqUUlYWBj169eXRauyb66npyeNGjXK93hlxQ5zc3MePHhQ8ALfQ911ffLkCfPmzcPNzQ1BEPj6668ZMWIEPXv2LNS+5NoSiW9qakpKSgoPHjzAzMxM5Zi5uTlJSUlq+1UrCQ0NxdraWpbeyV999RWBgYF5lsDPCzc3N77//ntq165dIJugHyK351FaWhqbNm1izZo1xMXFoa+vT/v27enduzfdunVTWxpTUxgbG5Oens6rV69y9GyrXLkyCoWC2NjYXEscZmZmUqFCBUqUKEFUVJTG9Sqfr+r6vStRbh43atQILy8vlWNy2QjK9f7Zs2ef9H3GxcVRvXp1ypYtS1hYWMELfAel1kePHuXIpomMjKR27doIgqD2OLwNdq1Tpw5lypThxYsXGtUKb3v4paamEhgYqJLN+C4ODg74+PjQo0cPdu/erXJMrjlQrVo1EhIS1K6tz58/p0GDBgiCwJMnT6hcuXKO8S9evKBevXp89tlnPH/+XKNaa9asSWxsLH5+flStWjXf45XPgYoVKxIcHKwBhaoor+3du3fV9r5UKBR89dVXPH/+nClTprBgwQKV43K+K2iT1uzsbP7880+WLl1KZmYmw4cPZ/HixbkmMBTWO5c22a42Njb4+/uzceNGlcpRH4sy4KFhw4ZcuXJFAwoLHp2DUIdstG7dmgcPHnD27Flat24t/Vzd4hQQEMDXX38tW0SbTqtO6/vMmjWLTZs28dNPP/Hbb7/lee6CBQtYvXo1s2bN0kivQR3yERsby7Fjx/jnn3+IiorixIkTuZ5rYmICgK2tLePGjaNdu3ZyyVThzp07knMoKCiI6OhoUlJSyMrKonTp0pQvXx5LS0tatmxJjx49ZKvZ/iFSU1NJTk4mPT1dau6cVxZuUSI9PZ2bN28SGRlJxYoVad68uVS6qyiQmJgozYFSpUpRtmzZj4p4K0x8fHwA8pVVUFjs27cPgEGDBhWykg+j05o/EhISOHDgAEuXLuX169dSeZiPKS/2LnJkEgcGBrJr1y62bt1Keno6giDQqFGjfJe9O3v2rIYUvqVixYpkZmYSGRmZo3x3cnIypqamCILA69ev1a5TaWlpGBsbY2BgQExMjEa1gnqbVLkRHxMTQ7FixXIdq1AoqFSpkixalQ4Adc6BjyE9PZ3KlStjaGjIq1evNKBQlbw2o27evMnChQu5cuUKgiBQtmxZunXrRo8ePbC1tc3VmaAptm3bxp49e7h79+5/+j2ajsRXOgeUJXrfRbkRn9ecVTqIihcvrhL0pAmU95A6rR9DamoqVapUoWTJkkRGRmpAoSof2jxNSEhgw4YNODs7ExERgSAI6Onp0ahRI+zs7GjatCkNGzb8pA37j6Vp06YEBwdz5coVGjRooHKsUaNGPHv2jIcPH6qUP3wXpRNDbsdASEgI5cuXV3tOTEwMjRs3JjExkVWrVjFs2DDpmNzOoadPn35SQOubN2+wsLCgXLlyhIaGakDhvyifA2FhYTmylxITEzE3N0cQBF6+fKnWNlA+g+VyEivXJXX2gBI/Pz/atGmDKIq4urrSqlUr6Zhcc0Bpt6hzZiufnXnpSElJwcTERBZboEqVKqSlpf3ntbVUqVJERERoQKEqykCB6OhoDAwM1J5z5swZBg0ahKGhIbdu3VJZR+V0bGmTViX3799n1KhRPH78mBo1arB582a++uqrHOcVloNQm2xX5XqV2/r5IZKSkqRSpOHh4RpQWPDk/oajQ0cB8/TpU4CP6slRo0YNAFkeUurQadUM2qTV1dUVQRAYN27cB88dM2YMq1at4ujRoxp3EObW67Aooo1aK1SowOjRoz9qzO3btzE2Ni50x0vjxo1p3LhxoWr4FEqWLKk1DsH3KVGiRJF2ZJUpUybHRkFRpyhfz/fRBmebEp3W/FG2bFnGjBnDV199JQV9zJs3r8iVxQawtLRk8eLFtG3blm+//RaAv/76q8hpNTIy4s2bNzx//pzatWurHCtdujQ9evSQNtfV8fLlS+ncwuLLL7/k3r17PH/+nJo1a+Z6ntLOza9D+VMwNjYmLCwMf39/mjZtmu/xDx8+BFCb/SA3X331FS4uLvj4+LB161ZcXV3Zv38/Bw4cQF9fn8aNG0sOl0+J4s4vI0eOZOTIkVLlE0EQimR5/Fq1anHnzh18fX3p0KGDyjFLS0vu379PUFBQrrqVpVRzy+QpSMqUKSNlu6nLxPgQSgem3M7i3ChbtqxUds7d3Z3du3dz4cIF/vnnH27fvg1oPou0e/furFq1innz5nHs2DGVTMHu3buzdu1a9u/fj5OTk9rxyt6ETZo00ZjGd6lduzY3b97kzJkzDB48WO05FStWZM6cOcycOZO5c+diY2Mje2BjnTp1uH79Ojt27Mi1PG9eKMtLv1/2VRNYWFgQGBjItWvX6NSpk8qxa9euSf/96NEjtc+JgIAAAFn60MJb5+vjx4/x9fXlm2++UXuOtbU1w4YNY/v27YwbNw5fX1/Z7/tKlSoRERHBgwcPcpS+LlGiBMuXL89zvDIjOzdHeEFSvXp1Hj16hIeHB927d8/3+EuXLkm/Rw6MjY158eIFjx8/zrVSkIODA3Z2dnh5eTFhwgROnz4ti7b30SatSho0aMCVK1dYsGABmzZtokuXLkyePJmff/45zwA3udAm29XQ0JDU1FQSExM/6R0kJSUFoFArYuSXoh1OruN/CmXUxcdEUyqjAQpr81inVTNok1alY7JixYofPFdZO1vTZUQAvvjiC8aOHcvp06dJTk7W+Of9F7RN65gxY/Kl1cTEpNCdg9pIQEAAp0+fZv369SxbtowFCxawZMkS1q5dy7Fjx/Dz8ys0bQ0aNKBFixbSy5KOguXVq1ecPHmSffv24ePjQ3p6+gfHuLq6arx/R168fv2ae/fucfXqVTw8PPD29ub27duyRFoXBAqFgqtXr3L8+HGuXLlCampqoerJzMzk9u3beHt7f3Rkvb+/P/7+/hpWpkqTJk2wtraW9TM/lY4dOxZKr+aPpWHDhgCsXbtW7fE9e/bkKCP2LkePHgXeliWSk+vXr0uR1YMHD0YURdatW5fnmD///BOQZ8Nd2atrypQp+V6PoqOjmTx5MoIg0LlzZw0pzD82NjY4Ozvz6NEjFi9ezJdffklmZiY3b97kr7/+yrMvtCaYPn26LM6zT2XAgAGIosi0adNylAf84YcfEEVRmpPq+O233xAEATs7O01LlTbZP7U/68KFCxEEgZYtWxakrP+Mnp4eXbt25eDBgzx69IiNGzfSr18/KlasSHZ2tkY/e/LkyZibm+Pp6UmHDh24fPmy1PZg+vTpVK9enWXLlnHgwAGVcZmZmaxatYrVq1cjCILa3q+aoE+fPoiiyOzZszl8+HCu12fMmDG0bt2apKQk+vTpIzmx5GLUqFGIosiiRYuYN2/eR2fXRkdHM3/+fGmujhkzRsNK3zonRFFk+vTpPH78WPr5kydPmDFjhvT/ua0DK1asQBAE2rRpo3Gt8LY3qiiKzJgxI8/SmwsWLMDc3Jznz58zaNCgj3pfKEhatGiBKIrMnTs3R9sGgNGjR+cZULxmzRoEQfgkB0h+6devH6IoMnHixHz3vLxw4QITJkxAEAT69++vIYWqtGrVClEUWbBgAVlZWbme9+eff1KyZEmuXLnCr7/+Kou299Emre9SokQJfv/9d06fPk2VKlX4888/adeunexrqTq0yXZVvr98aq9DZZssuYJwCgJdiVEdsqGsJ7548WKVFzx16c07duzA0dFRlubOOq06reqwsrIiKiqKc+fO5Ygce5/r16/TqVMnKlSoQEhIiEZ1bdy4EXd3d65evYqenh6tW7emW7du2Nvb56iRX9jotBYe58+fx93dXepHV758eRo3bkzfvn3zzH7QFCEhIaxduxYXFxdiY2M/eH758uXp1asXU6ZMoVq1ajIofItyLRIEAUdHR2bPnp1rSREdH096ejrTp09n7969KhtClSpVYs6cOQwdOjTXseXKlUNPT0/jvZyUZGdnc/z4cU6fPo23t3een1u2bFnatGlD37596dWrl+wZ0y9evGDXrl34+/sjCAINGjRg5MiR0ob2iRMnmDFjRo5+mY6OjkyfPl1WrfB2I2rNmjUkJiZKP7O2tmb+/Pk5sl/eRe45oMTR0ZGdO3cWycyh95kwYQL79u0rklqPHz/OsGHDEASBHj160K9fPywsLHKUxHsfhULBgQMHmD59OgqFIke5OU3xfv+5KlWqULt2ba5cuYIoisycOZPZs2erjAkMDOT333/n2LFjCILAoUOHNL558erVK1q1akVsbCxlypRhwIABdOjQAWtra6pUqaLyN2RnZxMZGYmfnx8eHh4cOnSI+Ph4jI2N8fX1lcUJ9qnlrMLCwrh8+TKXLl3iypUrGrez32fo0KGcPHmySN5b2dnZ9OjRA29vb8qVK8fIkSPp1auXFNwwYMAA3N3dGTRoEDNnzpTsqXv37rFo0SLOnz9PyZIl8fb21niW1j///EPnzp3JzMykWbNmTJ48mXbt2uWZGZSUlMSlS5dYu3Ytt27dwsDAgAsXLnxS36L8UhDl1x48eKDxLLLAwEAGDhzIkydPEASBcuXK0ahRI6pVq0ZiYiInTpxAEASqVatG3bp1USgU3Llzh7i4OMlZJ1d7DIVCgb29Pbdu3UIQBMqUKUOtWrVYuHAhtra2KudGRUXRsWNHnj17hoGBAXZ2dnh4eMhWEk/ZakQQBPT19WnQoAHW1taYmppiZGRE8eLFUSgUJCYmEh4ejp+fH35+fmRlZSGKIpMmTWLRokUa1/nmzRtsbW0JDQ2lWLFi1KpVC0EQCAwMJCsri++//56goCBu3brFwIEDmThxImZmZoSFhbF27VoOHTqEgYEBV65ckSUIJzo6mlatWkklG+3s7KhTpw6DBg3Ksb7eunWL7t27k5qaioWFBcOGDWP+/PmyzIHbt2/TsWNHsrKyMDU1xcHBAQsLizyDVMLDwwkODsbZ2ZkjR44gCALHjx/XeN/3jIwM7O3tuXnzJoIgUKdOHTp27Ej9+vUxMzOT5mt6ejpJSUm8fPkSf39/PDw8CAgIQBRFWrZsyZkzZ2TJMPP396dt27ZkZmZiZWUlfffNmjWTgu6V7N27V3Jg9u7dmwkTJvDNN9/Itg5ok9bcSEhIwMnJiUOHDlGiRAnmzp3LTz/9VGglRrXJdr148SJ9+/YFkPalPsb+uHv3LqtXr+bkyZMIgsDJkydlCcQqCHQOQh2ycfjwYUaNGoWhoSF//vmnVErq/cUpODiYDh06EBcXx59//snw4cN1WnVaZdc6cuRIjhw5QrNmzXBxccm1v1hqaioODg78888/2Nvb54jS1BQJCQmcP38eNzc3Lly4QEJCAtbW1nTp0oWuXbsWqZKTOq0Fj6WlJXp6eirRovA283XIkCHcuHEDQIokBqQSbsOHD2fJkiWylTvYv38/jo6OpKenI4oiJUqUwMrKClNTU0qXLi29tCj76AQGBqJQKBAEgZIlS7Jhwwb69Okji1blWtSmTRu8vLyoU6cO69atU1u7X8fHkZ2dTe/evfHy8kIURapVq0alSpUICgoiPj5ecsbOnz9f7Xg5X2AePHjAkCFDCAoKUrl3SpcuLc3VtLQ0kpOTVTLxBEGgbt26ODs7y1YK6+TJk4wdO5a0tDRJqyAImJiY4OLiQkBAAIMHDyY7O5vy5ctjamrKy5cviYuLQxAEfvzxxw9mQxUkY8aM4dChQ9IaULZsWclxqa+vz/LlyxkxYoTasYX1EnvlyhVcXV2ZNm1akc4iAjh9+jQHDx5k+fLlRTKoZdq0aWzbtk168f9Q6b2WLVsSHByMQqFAFEXs7Ow4efKkLFn78+fPJzg4mKCgIJ4+fZoje6Bu3boqpduuXLlCjx49gLfP3AkTJrBkyRKN64S3zoFhw4bh5+ensqmip6dHqVKlMDAwQKFQkJqaqhKcIYoiDRs2ZOfOnbIFDRXWffxfWb16NX/++ScXL14sMj2c3yUtLY1p06ZJPVzhbcUWMzMzDA0NCQgIkOaGkZERmZmZ0nOjbNmy7Ny5M88AjYLkxIkTTJgwgeTkZMkmtbCwyHUTOzQ0lOzsbERRxMjIiE2bNkn3mqbRpvmqUCjYtWsX27dvl8rGwtt19l1b5l2aN2/OrFmzci3zqCmSk5OZN28ee/fuJS0tDUEQ2LFjh1o7PzIykuHDh+Pr6yv9TM7vxMXFhWXLlqlUNlEXCPbuNW7YsCGzZs2ia9eusmiEt0EUw4cPl979lPTu3ZstW7bw9OlTunTpkuOZq2yvIfdeS0BAAMOHD5dKBeY1B65cucLgwYMl21WpWY45cPToUSZPnkxSUpKkM6/PNTMzIzk5WZoPTk5O/PLLLxrXCW+fA/PmzWPXrl1ST+oPIYoihoaGDB8+nAULFnxSP7hP5ejRo0yaNImUlBRJa25zYNWqVSpZeXLOAW3TmhenTp1iypQpxMXF0aJFC/7+++9C06ZNtuuGDRv45ZdfJB0VKlTI1fkeHh6Ov78/sbGxiKKIvr4+S5YskS1LvyDQOQh1yMrgwYM5deqUtJn29ddfs337dgRBYNGiRfj5+XHq1ClSU1OxsbHBxcWl0Er46bT+/9b65MkTWrduTUZGBpaWlsycOZMOHTrw2WefAW/LpHp4eLBs2TIeP36MIAi4ubkVSumbrKwsfHx8cHd3x83NjadPn2JiYoK9vT329va0bdu2yNS+1mktGNRtXCQlJdGuXTsCAwMB+Oabb7CxsaFChQokJCTw999/4+bmRlZWFt26dVPZTNIUf//9N127diUrKwtbW1umTJlCmzZt8rxuCoWCK1eusG7dOjw9PTEwMMDd3Z1mzZppXO+713XLli0sWLCAlJQU+vXrx/z58zE3N9e4hv81nJ2d+emnnyhRogSbNm2SIvFSU1NZtmwZq1atQhAE9u3bR7du3XKMl2uTLiwsDFtbW+Li4ihfvjxDhgyRIhrV9ROLi4vjwYMHeHh4sGfPHmJiYqhUqRI+Pj4a7+Xy4MED2rZti0KhoH79+nTp0gV9fX3c3d25d+8eX375Ja9fvyYuLo7Vq1czaNAgaWPF2dmZadOmkZWVxdGjR2XZGD516hSDBw9GT0+PefPmMX78eEqUKEFERARz587l6NGj6Ovr4+rqytdff51jvDZt1OrInQsXLrBnzx5u3bpFdHR0nmXbTE1NSU5OlrKiZs2aVSjPW1EUCQsLIygoSPqXlZXFypUrpXM8PDzo27cvDRo0wMnJiZ49e8qu09XVlePHj+Pj45Nn725TU1NsbGzo06cP9vb2MirU3ceaJiAggG3btnHhwoU8S/cB1KxZk169ejFhwoQcWRCa5uXLl6xbt45Tp04RHh7+wfPNzMzo1asXkyZNwsTERAaFbxk7diyCILBp0ybZPrMgCAsL4+7duwQFBREdHU1KSgpZWVmUKlWKChUqYGlpyddffy3rtVSH8r0kJCSE9u3bY2Vlleu5V69e5ezZs9y7d48XL15w9+5d+YTyNnDZx8eHwMBAXrx4QVJSEgqFguLFi2NkZIS5uTlWVlbY2NhQo0YNWbW9y/3796UN9wYNGqj0TAsODmbOnDlcuHCBzMxM9PX1+frrr5k5c2ahZbZcunQJT09PQkJCGDduHK1bt1Z73uvXr9myZQtubm48ePCA/2PvvMOiurq3fR8UxN4lFLvYQSNqLAhosGIveS2JjahBYsFo1DfGHkuwF4y99y5SVFQQUVFUFLAhKEU6Ir0z3x9+cyIyoChzgPc393XluuKcs5mHYc85++y11rOysrIku4/ExsZy+vRp7t+/T1RUFGfPns33XPl3qlu3blhZWYl9rKUkOjoaR0dH3N3dxfmanJxMeno65cqVo2LFiuJ87datG/369fusdjrKICQkhL1793L9+nUCAwPZuHEjgwcPVnjujRs3+Pvvv/Hw8CAnJ0fytURp0loQUVFRTJ06lStXrgDSJlwoojSsXQEePnyIra0tV65cISMjI9cxRYk45cqVo1evXsyePVsSx4OiRBUgVCEpWVlZLFu2DDs7O7FC5MPMd3mWxciRI1mzZk2xNiJXaVVpdXZ2xtLSkqSkpFzZt4IgiBZp8uyQlStXStJr4HN4+vQpjo6OODs74+XlRfny5enevTv9+vWjd+/exbYQVIRK65ehaKNt1apVrFy5kqpVq3L06FGFD1qPHj1iyJAhvH37lp07dzJixAil6vzPf/6Ds7Mzo0eP/qJNFisrK44cOYKFhQVHjhxRgsLcfPy5vnr1Cmtrazw8PNDQ0GD06NFMnz69WGxaP6YoslIFQfjifkCfS58+fbhz5w7z589n7ty5eY7/8ccfbNmyhTp16vDgwQMqV66c67hUm8rTp09n//79GBkZcfLkyUJtmr57946hQ4fy4MEDJkyY8MW9Cj4XeYW7hYUFBw8epEyZMsD7as0ff/wRBwcHBEFg2rRpLFu2LM/4+fPnY2dnJ9n3atCgQbi5uTFp0iRsbW3zHLe0tOTUqVM0bNiQu3fv5gkEqQIL//c4ffo09erVo127duL8LqnExsaSkJBAw4YNi1sK8L5CJ79N7IoVKxabLnlSktw9RIXyiIuL4+XLl8TExJCcnEx2djYVK1YUA0QlZW0dEBDwyU3s4gy4qFDxv0Z2djYxMTFUq1ZN0oqxoiIrK4uoqCh0dHSKW0oewsPD0dLSKrYk/P8LxMfH4+vrS2hoKP/5z3+KW06BlGStJ06cICAgACCPZX5xUVLXrh+SkpKCp6fnJ5NFOnbsmK/7XElHFSBUUSxER0dz7tw5Hj58SFRUFNnZ2dSoUQNDQ0P69+9fIjZf5ai0KofSojU0NJS1a9dy/vz5PL3Typcvj7m5ObNmzSqxzWdjYmJwcnLCyckJV1dX0tLSMDIywsLCguHDh5eoiiiV1s9H0YZ5p06dePbs2Sf7NB0+fJipU6diamrKhQsXlKqzcePGxMbG4uPjQ926dQs9Pjg4GAMDA2rVqiUuZJVJfoEIe3t7li9fzrNnz1BTU8PU1JRx48bRp08fypcvr3RdiqhduzaZmZlfPF4q25N69eqRkJCAt7c3DRo0yHM8IyODDh06EBQUxMyZM1m8eHGu41IFh1q2bElYWBiurq5flO338OFDzMzM0NPTw8/Pr+gFfkCzZs2IjIzEw8MjT3+jJ0+e0LlzZwRB4N69ewot8Z4/f07Hjh2pU6eOWHGsTBo0aMC7d+/y1ZOYmEi7du2Ijo5myZIlzJgxI9dxVYBQhQoVKlRIyZEjRyhfvnyx9Bf+v05YWBhhYWFoaGjQsGHDPIljKnITEhJCuXLlqFOnTnFLUaFChQoVpRhVgFCFChUqPpPg4GCio6PJysqiRo0aNGrUqMRntn9Ieno6169fx8nJiUuXLjF+/HjJGtMXFpXWglG0Yf7NN9+QlpZGQEBAgdVPb9++pWHDhlSrVu2TNlRfi1xTeHj4FwXSUlNT+eabb6hQoUKB1hNFRUGBCJlMxrFjx1i1ahWvX78WeyR+//33dO/eHRMTE0n7EyUkJHD06FFWrVrF27dvEQSBfv36KbTDLAhl22fJA5nR0dGoq6srPOfixYuMGTMGTU1NvLy8cgWTpQoO1alTh4yMDCIjI78oqzo9PZ06deqgqalJZGSkEhT+S61atcjKyiIiIgJNTc1cx+TfGUEQFB6H971KtLS0UFdXJyYmRqlaP9Rb0Bw4cOAA06ZNo2rVqjx8+DDXNawkBginTp2KIAhs3bq1uKV8klWrViEIgsIK3pKGSquK0kR6ejqvX78mMTERXV3dYrdtVEROTg4PHz7k5cuXpKenU6NGDb799tsS1as0Li5O7O0rz8SX2vr0Y+T3na5du7Jnzx60tLSKVc//CgEBAezatYvo6Gh27dqV69jx48f5+++/cyUElilThm7duvHnn39iZGQktVxSU1Nxc3MTLUZDQkJISkoiNTVVrHbV1dWladOmmJqa0r17d4XrLmVStWpV1NTUmDVrFgsWLCjxAe3s7GwuXbokurR8SEBAgNhiIjw8HA0NDRo3bsyAAQOYNGkSVapUkVxvfHw8e/fuxcPDg+TkZOrXr4+FhQX9+/cvcJzc3v/QoUMSKX1PQkICt27d4uXLlwQHB5OcnExKSkqe6uyuXbuKrXNKIj4+Pjg6OhIREUGtWrXo3r07Xbp0KTY9Xl5e3Lp1i6SkJOrXr0/Pnj0/GZSXP2NbWVlJIfGz8PT0xMfHh6SkJHR0dDA1NS32+1tiYiIBAQH5Xl/19fVL7FyVOx/8r6AKEKqQDPniJTIyssT0GMsPlVblUJq0FoS8lLy0Ex8fX+hgQnGh0pobRRvmdevWJTExkaioqALnZ0pKCtra2mhoaBTYA6ookFc1Hjx4kAEDBhR6vIODA6NHj6Zly5bcvn1bCQpz8zmBCJlMxuXLlzlw4ACXLl0iMzNTfBivUqUKbdq0wd7eXula5Tx48IDu3bsjCAJ37tyhefPmkr3359C6dWtCQ0O5efNmrn4oHzNw4EDc3NzyVLZKFRwyMDAgJCSEq1evftEmlLyCsF69evj4+ChB4b/o6+sTHR2Np6cnzZo1y3VMXh0oCAIPHjxQaM/26tUr2rZtS40aNXj16pVStQI0b96ciIgIvLy8aNKkicJzZDIZpqamPH78mCFDhrB3717xWEkMEJZETfmh0qocSpNWFYUnMDCQw4cP8+TJE2QyGa1atcLS0lK0tlu1ahVbt24VWw7A+2vdH3/88UXrnS9lyZIlCILAwoUL8xzbt28fq1atIiIiIs+xzp07s3TpUjp06CCFzFzcvXuXCxcu4O7uTkBAAElJSXnO0dTUpEmTJpiYmDB06FBJ+lB/iPz7DVC9enVWr17NDz/8IKmG/zX279/P7NmzyczMxMDAAHd3d/HYf//7X+zs7MS2I+rq6pQtW5bU1FTx35s3b2bUqFGSaM3JyWHNmjXY2dmJ1/iP+0x9yIdzxcbGhunTp0shE0B85hQEgU6dOmFnZ1dirXkfPXrExIkTCQgIyDMHzp49i5WVFWlpaXk+a0EQ0NPT4+jRoxgYGEim9+7du4wePZqYmJhcmgRB4LvvvuPo0aPUqFFD4Vip1wi3bt3C1taWGzdukJ2dDSies/K5WqZMGbp3787cuXMlvw+cPXuW7du34+vrK/bMnD9/PsbGxshkMubMmSMmEMgdbwBMTU3Zu3dvvp+5MoiNjWXixIm4ubnler1cuXJYW1srvPfKke99xsXFKVsm8L7yff/+/bnWLbNmzaJ3794kJiYyatQobt68mWtM2bJlmThxIitWrKBs2bKS6IT3+2W7d+/m/PnzPH78uMDrK4ChoSHDhg3D0tKyWFpQvXnzBgcHh1zJIsnJyaLu8uXLi8kiJiYmDBw4sERaIX8KVYBQhWTIN99u375NixYtiltOgai0KofSpFVOVlYWe/bs4eLFizx79kxcIMbFxeHv78/u3buZMmVKsfaeWbVqVZH+PGVWv6m0Fg2KHjoGDx6Mq6vrJwMct2/fpk+fPtStWxdfX98i06SItWvXsnTpUqpVq8bOnTvp1avXZ4+9cuUKkyZN4t27dyxatAgbGxslKn1PYR/mYmJiOHr0KM7Ozty9e1fsqyr1hrGxsTG+vr4lMkA4efJkjh8/Ts+ePTl+/Hi+VdcvX77E2NiYtLQ0bGxsWLRoESDdA/asWbPYvXs3hoaGnD59ulBWTdHR0QwbNozHjx/z888/s2bNGiUqhbFjx3LhwgWGDh3Knj17ch2bOHEip0+fRhAEFi9ezMyZM/OMX7duHUuWLMHMzIzz588rVSvATz/9hL29PSNHjuSff/7J97wHDx5gbm5OTk4Otra2TJo0CSiZgZiSqCk/VFqVQ2nSqqJwHD58mJkzZ5KZmZmrT3qNGjWwt7fH2dk5V/9eTU1N0tLSxPOkWrNA/vNwzpw57Ny5E5lMhpqaGo0bN6ZmzZokJCTw4sULsrKyKFu2LHZ2dpL1R4qIiGDy5MncuHEDKDjgIke+MdyzZ0+2bdsmWf9E+ed68eJFpk6dSnBwMN9//z2rVq2S1C3ifwV3d3cGDhxITk4O3333HdOnTxcrsBwdHcXA36hRo/jtt99o3LgxampqPHv2jL/++osLFy6grq7OjRs3aNmypVK15uTkMHz4cK5du4ZMJkNbW5vu3btjYGCArq4uFStWRENDg7S0NJKSkggLC8PPzw9XV1fCwsJERw8pejzDv3N13rx5rFmzhrJlyzJv3jysra3zdW0oDl69eoWpqamYSDtp0iSxn7qfnx9mZmZkZGTQqFEjpk2bRrNmzdDU1OT+/fts2bKFoKAgtLS0uH37tiQVxhEREXTu3Jm3b9+ira3NuHHjqFOnDt7e3pw4cYL09HRatmzJtWvXFFaNSrlGsLW1ZcWKFeTk5ADv2zsYGBigo6NDpUqVUFdXJz09ncTERMLDw/Hz8yM4OBh4HyhcunQpv/76q9J1Qt5kADlly5bl8OHDPH78mL/++gsNDQ169eqFnp4eISEhXLlyhczMTNq1a8fly5clCWalpaVhbm4uBjK7dOlC7dq18fHx4eXLlwiCwIgRI9i5c6fC8VLOgWnTpnHw4ME8n6uamhr79+/H0dGRo0ePUrZsWVq1akWtWrV4+fIlQUFBCIKAhYWF2Cta2Vy/fh1LS0vevn0r6q1atSo6Ojp5rq/h4eFiIpYgCNSpU4d9+/ZJVk2anJzM3LlzOXbsGFlZWZ+9blFXV2fs2LH89ddfkleVfw2qAKEKydixYwdz5sxh8uTJ2NraFrecAlFpVQ6lSSu8t7kYOnQoQUFBebLG3r17J1aMVKhQgZ07d37SakJZfJjl+jl8mIml6HVlLmJUWotW24IFC2jevDktWrQgICCAESNG0KVLF/FB+mOSk5MZOHAg9+/fZ9SoUUq3l8zMzKRv377cu3cPQRBo0aIFPXv2pHXr1ujq6lKpUiU0NDRIT08nKSmJN2/e4Ovri4uLC0+fPkUmk9G5c2cuXrwoyYPA1yzkU1NTcXd3x9XVlRUrVhS9uAKwsbFh7969JTJA6Ovri5mZGVlZWTRt2pQxY8bQvHlz2rdvn+cB/9ChQ1hbWyMIAkOGDMHa2prvv/9ekoeryMhIunTpQmxsLJUrV2bUqFGYm5tjYGAgWnbKycnJISIiAh8fH1xcXDh+/Djx8fFoaWnh4eFB7dq1lar1/v379OzZU9xos7CwQBAEHBwcuHPnDvXr1+fdu3dkZWVx/PhxjI2NxbGurq6MGjWK1NRUduzYIUlFhIeHB/369UMQBMzMzBg3bhwtWrSgfv36eayHbW1tWb58OWpqasyYMYOpU6eir69f4gIxpSk4pNKqHEqTVhWfjzxRITs7m6ZNm2JhYUGlSpXw8PDg2rVrGBoa8vr1azIyMli2bBmjRo2icuXKhISEsH79evbs2YMgCFy5ckWSqjdF8/DDgMtPP/3En3/+mctC7N27d9ja2rJlyxbU1dXx8PDIU41e1MTFxdGtWzdCQ0NRV1enf//+mJubY2hoKG5ifxx0ka8HHRwcyMjIoGHDhri5uUliM/jh55qcnMyCBQvYu3cvZcuW5aeffsLGxoZ69eopXcenSElJKZKfU6FChSL5OfkxePBgrl+/zvDhw9m1a1euNdWgQYNwc3PDysqKlStXKhw/fvx4zp49y8iRI9m+fbtStdrZ2TF//nwqVKjA2rVrGTlyJGpqap8cJ5PJOHHiBDY2NqSkpORKdFImH87Vx48fY2Vlha+vLw0bNmThwoUMHTpU6Ro+hylTpnDs2DHatm3LyZMncyXiWVpacurUKXr06MGJEyfyPMMmJibSr18/fHx8mD59eq4EDWUxf/58sRrz6tWruarWfHx8GDx4MLGxsUyePJm///47z3ip1ghOTk6MHDkSeG9ramNj81lJDP7+/mzatIkDBw4gCAKnTp3C3NxcEq2CIGBpacmAAQMoU6YM9vb27Ny5k8qVK5OWlkblypVxcnKiadOm4tinT5/Sr18/4uLiWLduHRMnTlSqVoDNmzezYMECqlSpwqlTp/juu+/EY3v27GHOnDlkZ2ezYcMGxo8fn2e8VHPg7NmzjB8/HkEQGDNmDEOGDKFy5cp4eHiwatUqKleuTFxcHFpaWhw/fhxDQ8NcY62trUlJSWHv3r0MGTJEqVqfPHlCjx49SE1NRV9fn6lTp2Jubl7g/TQ4OBgXFxe2b9/Os2fPqFSpEq6urkpP1klLS6NXr15ihWP79u3zrFs+Dr77+vpy9epVce/LyMgIJyenUuM+pwoQqpCUlStXYmtry88//8ykSZNKdAaeSqtyKC1a4+Pj6dq1KyEhITRu3Jg5c+ZgZGREhw4dxBt9QkICNjY2nDp1Ck1NTTw8PPK1T1MmBw4cICQkhLVr15KdnU3ZsmVp0aIFenp6qKurExwczNOnT0lPT0dNTY1BgwYV2A9OmUEjldai4UM7GTmamppkZGSQk5PDgAEDOHjwoHgsOTmZEydOsHnzZgICAihXrhxubm6SVPKmpaWxcOFC9u3bR3p6+mcFXWUyGZqamkycOJHFixdL5u1eWjd8b9y4gaOjI7/99pvSg1NfwqlTp5g2bRopKSni33/Pnj0KNy3Wr1/PkiVLxH9LkQwgx9/fnwkTJuDj45NrnqqpqVGhQgXU1dXJyMggNTVVzNKVa2zTpg179+6lcePGStcJ769PNjY2ZGVliVplMhk1a9bEwcGB+/fvi8HWNm3aoKurS0hICD4+PshkMnr06MHZs2cl0QqwadMmFi1aRE5OzifngI2NjbjJLv+9Str3sjRdK1RalUNJ0Jpf1nphkWIT+9KlS0Xyc3r37l0kPyc/JkyYwJkzZ+jZsydHjx7NtVEtrzSXV+socob49ddfOXjwICNGjMjTY00Z5Ococf36dUaPHl3g2lP++4wZMwY7Ozul6vzvf//L1q1badSoESdPnizU81JgYCDDhg3j1atXkgUHFH2ubm5u/PHHH/j4+KCurs7QoUOxtLTMtWksNYVNZlSEIAhKt8CTt0FQZH1er149EhISePz4cb6bxP7+/rRv3x4dHR2ePn2qVK1yVw47OztGjx5d6PGHDx9m6tSptGnTRqyWVSYfz9WsrCxWr17N5s2bSUtLo0mTJsyYMYPhw4d/UT/4okJuj3/58mU6duyY61jTpk2Jiorixo0buYIXH3Lz5k0sLCxo0qQJ9+/fV7redu3aERgYyNGjR+nbt2+e45cvX2bEiBGoqalx48aNPNanUq0RBgwYgLu7OzNmzMj1/PS5LF68mPXr10viKiJPBpg1a1Yea85ly5axZs0aBEFg/fr1TJgwIc94ebFBly5dcHJyUqpWADMzM7y9vfn777+ZPHlynuMbN25k4cKFVK5cmQcPHuRxn5FqDsg/12nTprFs2bJcx+QJD4IgsG3bNoU2zfLf4/vvv+fMmTNK1Sp3uunZsydHjhwpVOAsKyuLUaNGcfnyZX744YciWwPnx8qVK1m1ahW1atVi//79uRJuP8Xt27cZO3Ys0dHR/PHHH8yZM0eJSosOVYBQhWTI7UseP35MeHg4ABUrVqRatWr5Wo7Jz5calVblUJq0rl69mhUrVtCmTRscHByoXLkyoPhG/8svv3D06FEmTJjAhg0bJNf69u1bjI2NCQsLY8KECfz222/o6enlOicqKoo1a9awfft2jIyMcHZ2LpZMFpXWosHFxYWXL1+K/wUEBBAaGioGLT7u2efi4sKwYcOA91nC27ZtY/DgwUrX+SHR0dE4Ojri7u6Ov78/oaGhJCcni82dP2yc3q1bN/r16yeZlZSckrDh+79KSEgIe/fu5fr16wQGBrJx48Z85+CNGzf4+++/8fDwEANKUv5NHB0dOXPmDDdv3hTvVYrQ0dHB2NiYoUOHKtw8UDbPnz9nz549+Pj4oKamhoGBAVOnTqVu3boAbN26lSVLlpCeni6OEQSBkSNHsn79esk3iry8vLCzs8PNzY2YmBj27t2bb2b74cOHWb16NUFBQQAl7ntZmq4VKq3KoSRoLYrgACDJ71BaAhnynqnu7u55Nny9vb0xNTVFEATu37+vMCHEz8+PLl26oKenh5+fn1K1guJ5WL9+feLj47l7926uCoyPefnyJUZGRujq6vLkyROl6mzTpg1BQUE4ODjQtWvXQo+XBwcaNmyIt7d30Qv8iIK+36dPn2bFihWixZy+vj5Dhw5l4MCBtGrVSunaPmThwoWcOHGiwLXK5xAfH19EihSjra1NamoqkZGReZL+tLS0SE9PJzY2Nt/9gKysLGrWrClJ/3S51jdv3lCxYsVCj09KShKtSMPCwpSgMDf5zdWIiAhWr17NwYMHycrKokqVKgwfPpwhQ4ZgbGxcJPeOwlCnTh0yMjIUzoHatWuTmZlJTExMvo4xGRkZ1K5dG01NTSIjIyXT+/r1a6pVq6bwnJ9++okLFy4oDK5JtUaQX+/9/f2/KEk0KioKfX19qlWrJq65lYU8GcDHx0d8VpETEhJC69atEQRB4XF4X0lmYGBA1apVRYtUZaKrq0tycjJPnjxR2E9OJpNhYmKCj48P48aNY+PGjbmOSzUHGjRowLt373j06BH169fPdUyeXCEIQr6/h7w3fc2aNQkMDFSqVnkywL17976oUOT58+d07NgRLS0tXrx4oQSF/9KhQwf8/f3zTRL4FPKK2WbNmnH37l0lKCx6VAFCFZIhr3gpDMX14K3SqhxKk9auXbvi5+eX50FW0Y3+6dOndOrUifr16xdLMHPevHls27aN6dOn58ka+pjFixezYcOGfDOflY1Kq/LIyMggICCAly9fkpCQwJgxY8RjLi4uzJgxg4EDB2JtbZ0n0KlCRUkkPj4eX19fQkNDJeuR9DHJycmEhoaSlJRERkYGGhoaVKpUCT09vS/aOJKaqKgorly5QmRkJLVq1cLExIQGDRoUtywSExNRV1f/ZF+GJ0+e4O3tzZs3b0pU9qW8T8eH19mSyooVKxAEgfnz5xe3lE+i0lo4/P392bdvHzt37hQr9Nu2bVvoa5ODg4OSFP7L5cuXOXjwIBcuXBBf09bWLnSPLB8fn6KWlotatWqRlZVFeHh4niSKhIQE6tatiyAI+W5kp6am8s0330gSyADFzyWfs9kO723ga9WqJYnWgoIDn0N6ejp16tSRLDjwqY3dnJwcjh49ys6dO3n48KEYbKlduzbdunXDyMiItm3bflEwtLBkZGQwZ84c9u3bhyAInD17ttBuBsq2S+3SpQtPnjzB2dmZTp065Tr23Xff8fz5cx4+fEjDhg0Vjg8ICKBdu3aSbAo3bNiQuLg4nj17xjfffFPo8fKAS/Xq1Xn9+nXRC/yIT83V169fs3r1as6cOUNaWprYT9XExARTU1OMjIxo2bKl0ls5GBoaEhwcrDAw0Lp1a0JDQ3n58mW+yaHR0dE0adJEss9VT0+PpKQkQkJCxETxjwkKCqJDhw5kZGRw8OBBBgwYIB6TKjgkD2KFhoZSqVKlQo+XB7QrVarEmzdvlKDwX+T3prCwsDy2xikpKWhrayMIgsL7L0h/f5UnL0RFReWbAC5PXilbtizu7u65eqRKNQdq1qxJdna2ws9N/pkVpCMtLQ0tLS3U1dWJiYlRqtbStBaQ//3zm4+fQv7Zly9fnoiICCUoLHpUAUIVknHz5s0vGleYUt6iQqVVOZQmrTo6OqSkpBAdHZ1r80LRjV5+o5JqsfIx8gV3fllBHxIeHk7z5s3R19fHy8tLIoX/otL69eTX67AgcnJyPqt/hgoVKlSoUKGidHHlyhWGDx+OIAglshfth3zYa7YkapVXOHh5eeWxwZTJZJiZmQHv7SYVERQUhKGhIVWqVCEkJETZchU+l3Ts2JEXL17g5+eHrq5uvmPlVQNSVI7IKzM9PT2/qN/hixcv6NChA9ra2jx79kwJCnNTmI3dJ0+esG/fPk6cOCFWuAqCIEnFq5z09HT09fVJSEgokd+rNWvWsGzZMtq2bYu9vX2uPpJ///03f/31F9bW1vn28P711185dOgQgwYNYv/+/UrVOnjwYFxdXZkyZQqrV68u9Hi5na4Udn3w+XP13bt3HD16lIMHD4rVzfLnSQ0NDaKiopSq87fffmPXrl0MHz6c3bt35zo2c+ZM9u3bx9q1a7G0tFQ4Xt4Prlu3bly8eFGpWgFMTU159OgR+/btK9B156+//uLvv/+mVq1a3LlzR6zikyo4JNe5ceNGxo0bV+jx8nvyt99+i6ura9EL/AD53oqTkxOdO3fOdez27dv06dMHQRDw8PBQWI3t6+tL165dJbEaBvj222959eoVly5dKtBKWt4jtU2bNly7dk0Mtks1B5o0aUJMTAxubm60adMmz/E//vgDQRBYvny5wvHyqjwpKgjln+mFCxcwMTEp9Hh3d3f69+9P48aNefDggRIU/ov8c/X29v6i5Fp5xWvt2rV5+fJl0QtUAspNE1Gh4gOKI8jzpai0KofSpFUeFIyPj/+kzaE8e6W4fP3ltjKfY8dYs2ZNAEk2LRSh0vr1NGzYkN69e2NhYcH333//WZUCquDg/zbv3r1DJpNRvXr1XK9nZmZy9uxZfH19SUxMRFdXlx49etCuXTvJNcbGxvLixYs8D4TZ2dmcPXsWNzc3wsLC0NDQoEmTJvTv379Y+/rA+yq3gIAAQkJCSEpKIjU1VbTD1dXVFS15ioP+/ftTvnx5lixZkitbtSSTk5NDUFCQwgqBu3fv5pkDffr0UWgxVBJIT0/n9evX4vdKW1u7uCWJxMXFkZycTGpqqljxKr9HlQZSU1NJSkqiZs2aJf7eVVK09uzZkyZNmhAQEFBsGj6XH3/8kZUrVyq9UuFLadmyJXfu3OHQoUMsXrw41zFBEPINDMpxdnYGkLzHenh4uHgdGjlyJEuWLGH37t15+jx9iHyTPr+eX0WJiYkJx48f5/fff+fYsWOFemZKT09nzpw5CIIgBmhLEi1bthSDXJ6enly/fp1r167x6NEjyTSUK1cOY2NjHB0dJXvPwvDrr79y+vRpvL29MTY25rfffmPAgAHUqFGDGTNm4OTkhJ2dHVWrVmXGjBmiu0BsbCzLly/n4MGDlClThmnTpild67Rp03B1dWX79u1ERkYyc+ZM2rZt+8lx3t7ebNiwgXPnzqGmpsaMGTOUrrUwVKtWDSsrK6ysrPD29sbJyQlXV1e8vLzIyMhQ+vvb2Nhw6tQpTp8+TVpaGkuWLBGTMObNm8f58+dZtGgRzZs3z1N5e/r0aZYuXYogCIwfP17pWgH69euHt7c3c+bMQVtbO99nkjlz5nDx4kWePHnCkCFDOHv2rKT94H/66Se8vb35/fffyczMZPz48Z9VDZqVlcX+/fvF4NGXBBcLS69evdi5cyfz5s3j9OnT4h5LbGxsLgemf/75h82bN+cZb2dnhyAIeaqQlYWZmRmBgYHMnz+fc+fO5Ups+JDVq1fj6urK48ePmTp1Kjt27JBEn5z27dvj7OzMihUrOH78eJ7jf/31V4HjpVwLDBw4kA0bNmBtbc3x48cL9Qz75MkTMcFs0KBBSlT5nu+++w4HBweWLl3Knj17Cj1efs36eO+jJKOqIFShFOzs7EhISMh1oV+1ahWCIDB37txiVJYXlVblUJq0KqJ///7cvHlTzGiUoygTaM+ePdjY2PDdd99x+fJlybXKvbw/ld0E4OnpSa9evSTJEFKESuvXY2dnh7OzM7du3UJNTY2uXbtiYWFB3759C8wUV/G/RXZ2Nra2tuzfv18MZmtrazN79mwsLS2JiIigf//+Ysbah5Wnffr0Yfv27V9k+1xY4uPjmT9/PidOnKBly5bcuHFDPPbixQvGjBmDv7+/qBHIpfOff/6RNAgXHx/P7t27OX/+PI8fPxY15YehoSHDhg3D0tLyi6x9vhT5vUhTU5NVq1ZJtmHyJWRmZrJ27Vp27tyJrq5urjkQFRXFzz//nOs1OWXKlMHS0pK//vqr0DaEX0NgYCCHDx/myZMnyGQyWrVqhaWlpVhJvmrVKrZu3UpiYqI4pnnz5vzxxx+57KWk4u7du1y4cAF3d3cCAgJISkrKc46mpiZNmjTBxMSEoUOH0r59e8l1xsfHc/78efz8/MTPdcSIEaLN1JEjR7C1teXVq1fA+w1vU1NT5s6di5GRkUrrJ7C2tubw4cMlsnroYyZPnsyJEydKpFb5mr5MmTJMnTqVESNGUL9+/c+6D12/fp2xY8eSmJjIkiVLJAkQfNjbsUqVKjRv3pxGjRpx/PhxBEFg/fr1eTZ+ExMTWbt2rdg3ffv27Uq38fb398fMzIzk5GTq1q3LlClT6NmzZ4HVhM+ePcPFxYUdO3YQFBRElSpVcHNzo1GjRkrVCkVT+REfHy/JOkvO8uXLsbW1xdPTs8R9r+B9EGDChAm4ubmJFZb169cXe2a5urqK65pGjRqRkZFBYGAg2dnZlC1blg0bNvDTTz9JonXr1q38+eefYm/3mjVr0rp1a9GKUUNDg/T0dJKSkggLC8PX15fY2FhkMhllypRhxYoV/PLLL5Jo/dq5mpSUhLu7uyS9tD09PRkzZgzR0dEIgkCrVq1o164d9erVIyQkhP379yMIAl27dqVVq1ZkZmbi6ekprsd+/PFHtm7dqnSd8P46aWpqSkBAAIIg0LRpU1q2bMm0adPy3Of9/f3p3bs3b9++pUqVKgwbNow9e/ZI1irnxx9/xN7eHkEQqF69OqamprRu3RodHR0qV66Muro6GRkZJCYmivPVzc1NTDAdMmQI+/btU7rO8PBwunTpQlxcHFWqVOG7775DEAQ8PT2Jj4+nR48ehIaG4u/vz9y5c5k6dSpVqlQhPj6eTZs2sXbtWoDP2pspCl6/fo2xsbGYCDZo0CBatGhB796989gyX7p0iVGjRpGTk0PHjh355ZdfmDBhgiRz4Pr16wwePBhBEPj2228ZNmwYDRo0oH///gWOCwoKYv/+/axfvx6ZTMaePXvy7Q1fVCQmJmJiYkJgYCBly5alZ8+emJubY2BggI6OjsLrq4+PDy4uLri4uJCVlYW+vj5ubm5Kb/Vx//59evfuTVZWFu3bt2fGjBl07969wOf9pKQkrl27xqZNm/Dy8kJdXZ0rV658VpJJSUAVIFShFL755hvS0tJy+fVKVWJdWFRalUNp0qqIEydOMGnSJDQ1NVm3bp3YZ+jj3yEgIABzc3Pi4uJYt24dEydOlFzrzz//zMmTJ2nfvj329vZ5PN3lpKam0r9/f+7fv0/fvn05evSoxEpVWouShIQELl++jJOTE1euXCEhIQEDAwP69OlDv379+PbbbyXRoUJ6cnJyGDFiBFevXs0TwBIEgbVr13LlyhWcnJyoWrUqJiYm1K5dG39/fzw8PJDJZHTs2BEnJyfKlCmjNJ1JSUn06tVLfLA3Nzfn9OnTAMTExGBsbEx4eDjq6uoMGDCAZs2aUb58eR48eMDFixfJzs6mQ4cOODo6ShIgun79OpaWlrx9+1b8XKtWrYqOjg4VK1ZEQ0ODtLQ0kpKSCA8PFwNEgiBQp04d9u3bR5cuXZSuU65LvmHx4sULzMzM2Lx5c4mruMvKymLYsGG4ubkhk8kwMjLi2rVrwPv50aNHD168eIFMJqN9+/Y0a9YMTU1NHjx4IPZ1kvK6evjwYWbOnElmZmaugHWNGjWwt7fH2dmZpUuXiudramqSlpYmnrdo0SJsbGwk0RoREcHkyZPF4Oqngtnwb/C9Z8+ebNu27bMq5IuCq1evYmlpmWf916BBA+zt7XF1dWXatGkKfwd1dXW2bNnCyJEjVVoL4MKFCxw7dgxbW9sSnyx04MABduzYwaFDh0pET9QPycnJYfTo0Tg5OYnfl09ZRY4YMYKnT58SGhqKTCajdevWuLi4SOIsMn78eAIDAwkMDMyVtCCnZcuW3L59W/z33bt3GTBgAOnp6ZJuDMN7C7nx48cTEREhfrbq6upoa2tTqVIlcRM7KSmJiIgIMjMzgffXNm1tbfbv3y+Zs0BpemaVk5mZSUpKClWqVCl0KwIpcXZ2Zvfu3bi7u5OamlrguZUqVaJPnz7MmTNH8qDnw4cPsbW15cqVK3kq7ARByHMPKFeuHL169WL27NmSbgaXtrkaGxvL+vXrOXDgAPHx8cC/a5MPP9MPP2MdHR3mzp0reTJcREQE06ZNExPABUHIN4jy5MkTxowZQ2BgoKhdyr/Lli1b2Lhxo2gVW9A1QP65amlpYWNjg5WVlSQa4f33auzYsQQHB+d6vWPHjpw6dYpnz54xaNAg0tLSUFNTo1KlSiQmJiKTyZDJZMyePZs///xTMr3u7u5MmDBBbCNU0Bw4ceIEv/76q9gTWso5sGnTJhYvXkx2dvZnWVzL7dTh/Xz4z3/+I1nlY2xsLNbW1jg5OQEFz1U58jnbv39/Nm3aJJkzytmzZ7G2tiY5ORlBEFBTU6N+/foKk0XevHlDcHAwOTk5yGQyKlWqxLZt2xg4cKAkWosCVYBQhVIwMDAgJCSEkSNHit7CVlZWCILAtm3bPmsTQ87o0aOVJRNQaVUWpUlrfowdO5bz588jCAItW7akU6dO7N69W/Tw9vHx4fz586SmpmJsbIy9vX2xWEy9ePGCrl27kpmZib6+PnPnzsXc3FzMdo6Pj8fFxYXVq1fz/PlzBEFQ6P2u0lp6tWZnZ3Pz5k2cnZ1xcnLi1atXaGtr07dvX/r27YuZmVm+zbVVlD727t3LzJkz0dDQYPbs2QwdOpRKlSrh4eHB7NmzycjIICUlBX19fc6fP5+rh+a9e/f44YcfiIuL++J+FZ/LkiVLWLduHbVq1WL79u2Ym5uLx+Q9Who1asTJkyfz9Hp69OgRQ4YM4e3bt6xevZopU6YoTSe8f7Dv0aMHqamp6OvrM3XqVMzNzfNkiH5IcHAwLi4ubN++nWfPnlGpUiVcXV0lsZaTbwhFRUWxdOlStm7dSrly5bC2tmbWrFlKz6r8XDZs2MCiRYuoUKECf/31F6NHjxatw1atWsXKlSupXbs2e/fupVu3brnGOjk5MXHiRFJTU/nnn3+UHnR58OAB5ubmZGdn07RpUywsLMTv1bVr1zA0NOT169dkZGSwbNkyRo0aReXKlQkJCWH9+vVitviVK1eUXqEXFxdHt27dCA0NRV1dnf79+2Nubo6hoWGuDFx5QFueMe7i4oKDgwMZGRk0bNgQNze3fC2Tigp/f39MTExISUmhZs2amJqaUrlyZe7evcvTp08xNTXl6dOnxMTEYG1tzahRo8SEhg0bNnD58mXKlSvHzZs3adq0qUqrCqUjz6Q/cOAAvr6+ZGVliRvZitDR0SE5OZkyZcowdOhQbG1t81h+S0FERAQvX77M9V+ZMmU4fPiweI6LiwvDhg2jdu3azJgxA2tra0mfXVJSUti3bx/nzp3Dy8uL7OzsfM8tW7Ys7du3Z8iQIYwbN07SVg4rVqxAEATmz58v2Xv+XyM9PZ1nz57x8uVLoqOjSUlJITs7mwoVKlCzZk309fUxMDAo9ueXlJQUPD098ff3JzQ0lKSkJDIyMkQLbz09PZo2bUrHjh3zTSZVJv369UMQBBwcHCR/768hOzubO3fu8PDhQwICAoiOjiY5OZmcnJxcc6BTp0507NixWIPe/v7+uLm5ERgYyIgRI/JNws3MzOTUqVM4Ojry6NEj3rx5Q2xsrGQ6MzIy8PDwwN3dnZcvXxISEkJycjLp6elii4S6deuir69Pt27d6Nq1q6QOHR/qvHz5Mo8fP0ZNTQ1DQ0N69+4tJq16enoya9YsfH19xTH16tVj3rx5YtK+lCQnJ3Py5ElcXV0JDAxkwYIF9OrVS+G5/v7+rF+/HicnJ96+fStpkPjZs2ccOnSI+/fvExUVxf379/M9V1tbm5SUFFq0aIGVlZUkFrMf4+Pjw9mzZ7l58yb+/v68ffs2zzk1atSgadOmGBsbM2TIEFq3bi25zjdv3rB582bOnz9PWFjYJ8/X1dVl8ODBTJs2rUS1oPgcVAFCFUph5cqVop3k16LsC6pKq3IoTVrzIysri2XLlmFnZ0dGRkauTLYPs4JGjhzJmjVrJLWX+xhnZ2csLS1JSkoSP/NKlSohCIKYUSy3PVm5cqXSN9tVWouXp0+f4ujoiLOzM15eXpQvX57u3bvTr18/evfuLVnVCFAkC05BECTJcC8tWnv37o2npyeLFy9m5syZuY4dPHiQX3/9FUEQOHTokEJ7kX379jFjxgy6du2q1H41bdu25fXr1+zbt4/BgwcrPHbixIl8H7Lkldzt2rXj+vXrStMJMHHiRE6fPk3Pnj05cuRIoTaksrKyGDVqFJcvX+aHH35g586dSlT6no8zxj09PbGysiIgIICaNWtibW3NpEmTlB78+RTfffcdz58/Z8OGDXkyvzt16sSzZ8/YvXs3w4YNUzh+586dzJ49W+lzFWDChAmcOXOGnj17cvTo0VybJrNmzRIThObNm5fLPl3Or7/+ysGDBxkxYgS7du1SqtZPBdgLIjAwkGHDhvHq1SumT5+eqyJSGUybNo0DBw5gZGTE6dOnxcBJdnY2EydO5Ny5cwiCwJQpU1i9enWe8aNGjcLR0ZHx48ezceNGlVYVkpKZmcnbt2/R0tLK95wNGzZQt25dsVq/JBMaGkpAQABdu3b9rD5VyiQtLY1Xr17lu4ndqFEjypUrV6waVahQoUJF8RAcHExERAS1atWSxFq6qAkJCeHNmzeS9UwsDJ6enjRo0KDAtY3UpKam5lkLSJkY9DkEBASIySIfa5Uni5TGuSpHFSBUoRRkMhm7du3i+vXrYsblzZs3RU/xwqDsbCiVVuVQmrR+iujoaM6dO8fDhw+JiooiOzubGjVqYGhoSP/+/WncuHGx6pMTGhrK2rVrOX/+fJ5stfLly2Nubs6sWbNo165dMSn8F5VW6YiJicHJyUlsRp+WloaRkREWFhYMHz4cPT09pb6/vr4+UVFRuZIFClNBDEiWfVdatMptQfz8/PJYyQUFBWFoaIggCLx48YI6derkGR8aGkqrVq2oVq0aQUFBStNZu3ZtMjMzCQ0NzZNAUadOHTIyMoiIiBAryj4mKSlJtPB48+aN0nTCvz1H792790UVgM+fP6djx45oaWnx4sULJSjMjSJLqYyMDHbs2MH69euJiYmhYsWKjBgxgp9++qlYes7Bv3/nV69e5amo0dLSIj09nZCQECpXrqxw/Nu3b2nYsCFVq1bNY0dU1DRv3pyIiAjc3d0xMDDIdczb2xtTU1MEQeD+/fsK7/t+fn506dIFPT09/Pz8lKq1TZs2BAUF4eDgUOg1Fbxfj1lYWNCwYUO8vb2LXuAHGBoaEhwcrLBnjLx/r7wHjaJ+ZA8ePKB79+40aNCAR48eqbSqUKFCxReQmpoq9tIqDsebzyE6OpqAgADS0tKoUaMGLVu2LPZAtiLkm8IlAQ8PDzQ1NYut/+3/dbKzs3n79i3q6uqS9kxXoUKFiqJGFSBUIRmlyR9dpVU5lCatpZ3g4GCio6PJysqiRo0aNGrUSKm9xr4GlVbpSE9P5/r16zg5OXHp0iXGjx+vsBKmKJHJZDg7OzN//nxevXqFIAhMnDix0Fn2Utg8lRattWrVIisrS2HgLT09nTp16hR4rU1JSUFbWxt1dXViYmKUprNZs2ZERkby/PnzPBmKjRo14u3bt7x58yZfO8zk5GSx/9/nWHp8DfJAVmRk5Bdt+sg/d01NTSIjI5WgMDcF3U+Tk5PZsmULW7duJT4+HkEQqFu3LgMGDKB79+507dpVMhusxo0bExsbqzBAWL9+feLj4wv8zNPS0tDS0qJ8+fJEREQoVav8e/Vh72Q5CQkJ1K1bF0EQiImJUbhhmZqayjfffIOGhobYq0RZlKb5Kk8UCAsLyzPv4uLiaNCgAYIg5Pu7yK8D5cqVE3vrqLQWDrmjx9y5c4tbyic5cuQIUHztBQqDSquKkkB8fDznz5/Hz88PmUxGq1atGDFihHgNO3LkCLa2trx69Qp43yvP1NSUuXPnShpU2rt3L/C+Wv9jrl69yvLly3n48GGu1zU1NRk0aBDz588vln6lb968wcHBQbTAk1e7ypMHy5cvj66uLk2bNsXExISBAwfmsvWXAvl6cMSIEWzcuLFYbE7/V3n37h1Hjx4lLCyMZcuW5Tp269YtbG1tuXXrFunp6QDUrFmT/v37M2vWLOrXr18cknn69Cnu7u655mtKSkquKid9fX1MTU1p1aqV5PqqVq1KhQoVWL16NWPHjpX8/b8EX19fXrx4kafv4Lt379izZw9ubm6EhYWhoaFBkyZNxCTs4kjEyM7O5vz583h4eJCcnEz9+vWxsLDA0NCwwHHz589HEARWrFghkdJ/efr0Kf7+/gQHB5OcnExqaqpo4Sy/vn6cuFncxMXF5dEqVV9EZaIKEKqQjKLw8v/777+xtLRU+pdPpVU5lCatVatWRU1NjcjIyGLvffA1yHsklAZUWqUnPj6eqlWrSvJeAQEBtG/fHplMxp07d2jevLkk7/sllHStLVq0IDw8XGGVCyA2GZ88ebLC8Y8fP6Zbt25Kr3b76aefsLe3548//mDOnDm5jo0ePRpHR0eOHj1K3759FY4/d+4c48aNo3Xr1nh4eChNJ8C3337Lq1evuHDhgtg3tzC4u7uLFeUPHjxQgsLcfE7CTUJCAsePH+fAgQM8fvxYrIwtW7YszZo1o23btmzdulWpOocMGcL169dZu3YtlpaWuY4NGjQINzc3Ll68iLGxscLxV69eZejQoejr6+Pl5aVUrfLKXC8vrzyWnTKZDDMzMwDc3NwUjpdX71apUoWQkBClapVXO+ZXyfYpXrx4QYcOHdDW1ubZs2dKUPgvenp6JCUl8ejRozwbZjk5OTRq1Ag1NTUCAwMVjg8LC6NFixaSJAqUJq2FoTQl6MnX33FxccUt5ZOotKoobq5evYqlpWWe73aDBg2wt7fH1dWVadOmKXTDUFdXZ8uWLUrv7ysnvzm4adMmFi5cKGqsUKEC1apVIzExUWznUKVKFQ4dOoSpqakkWpOTk5k7dy7Hjh0jKyvrs9xEBEFAXV2dsWPH8tdff+XrjlHUfPgc17hxY7Zu3Urnzp0lee//ZS5fvsyUKVOIi4vDwMAAd3d38djWrVtZsGABMpksz9wQBIHKlStz4MABunfvLpneY8eOsWbNGl6+fAkU7IAjfx5o1qwZ8+fPz9MGQpnI56sgCAwbNow1a9YUS8/ezyEkJAQrKytu3ryZZw7cvn2bH3/8kdjYWIVzoE2bNhw6dIi6detKpjcwMJCRI0eKz/bydkgAw4YNw87OLt+kQqnXiYGBgWzatAl7e/vP6tNZo0YNBg8ezMyZM6lXr54ECnNz9+5dLly4gLu7OwEBASQlJeU5R1NTkyZNmmBiYsLQoUOLzb3na1AFCFWUKmrWrImHh0eJ26xVhEqrcpBKq4GBASEhIdy+fZsWLVoo9b2KiqysLPbs2cPFixd59uwZMTExyGQy4uLi8Pf3Z/fu3UyZMoWGDRsWt1SV1iJm1apVRfrzlFVVaG5ujpeXV4kMun1MSdY6fvx4zp49S8eOHbG3ty/0JoSlpSWnT5+mb9++HD16VEkq31vy9e3bF0EQWLZsGb/88ouYTenl5UWvXr1o1KgRly5dypP0ERgYiIWFBeHh4SxcuJBZs2YpTSfAokWL2LBhA/Xq1eP48eO0bNnys8c+efKEkSNHEhwcjI2NDYsWLVKi0vcU9kHOx8eH/fv3c/nyZdFWVooHwUuXLvHDDz9QoUIFdu3ahYWFhXjsypUrDB8+HCMjIxwdHfPM47dv39KnTx9evHghyefap08f7ty5w8yZM1m8eHGhx2/fvp3ff/8dIyMjrl27VvQCP2Dy5MkcP34cMzMzjh07VqgeHenp6fzwww+4ubkxcuRI/vnnHyUqBTMzM7y9vVm6dCnTp08v9Phjx44xZcoUSRIFSpPWwlDaAoQqrUVPadKq4vPw9/fHxMSElJQUatasiampKZUrV+bu3bs8ffoUU1NTnj59SkxMDNbW1owaNYratWvj7+/Phg0buHz5MuXKlePmzZs0bdpU6XoVzcHbt2/Tp08fALp3786CBQswMjISN7WfPHnCypUruXDhApUrV8bT0zOPtX5Rk5aWRq9evXj8+DEymYz27dtjbm6OoaEhOjo6VKpUCXV1ddLT00lMTCQ8PBxfX1+uXr3KvXv3EAQBIyMjnJycJEkmlX+udnZ2zJs3j8TERMaPH8+CBQv+JypaioPHjx9jbm5Oeno6DRo04Ndff2XSpEnA+znbt29fZDIZxsbG2NjY0KxZM8qXL4+Xlxe2trZ4eXlRuXJlbt26JUkwY9q0aRw8eBCZTIampibt27fHwMAAXV1dKlasiIaGBmlpaSQlJREWFoafnx9eXl6kpaUhCAKTJk3C1tZW6Trh3/k6evRoDh8+jJaWFqtWrcpTnVfcREdHY2JiQnh4OGpqaowaNUpMqgwKCsLY2JiEhASqVavGhAkTaNq0KeXLl+f+/fscOHCA+Ph49PX1cXNzy9cppyiJj4+nW7duBAUFUaFCBQYPHkydOnXw9vbG1dUVQRDo1q0b58+fV1jZKOUa4ciRI9jY2JCeno5MJqNcuXI0bdpUdA3S0NDIdX319/cnIyMDQRAoX748W7dulWy+REREMHnyZG7cuAF8XusZ+f2rZ8+ebNu2jVq1ailVY1GiChCqKFXUqFGDW7dulbjNWkWotCoHqbTu2LGDOXPmMHnyZMkWTF9DQEAAQ4cOJSgoKNeNS36jf/jwIWZmZlSoUIGdO3fSv39/ldb/Ia3yRd3n8mFGmaLXlbU4/P3339mxY0eJDLp9TEnW+uDBA3r27El2djY6Ojr079+f+vXrY21tne+YsLAwAgIC2L9/PydPnkQQBM6cOUOPHj2UqnXHjh3MnTsXmUyGnp4eFhYWtGvXjvr16+Pg4MCmTZuoU6cOEydOpHXr1mRkZODp6cmRI0dITEzE0NCQq1evKn2TJTExERMTEwIDAylbtiw9e/bE3NwcAwMDcUNI/sAif8D28fHBxcUFFxcXsrKyJH0Q/JoHucDAQK5du4arqyuHDh0qenEfIQ++CoJAx44dGTRoEEZGRtSrV0/smdiyZUt+/fXXXHPAzs6ON2/eULduXW7dukWVKlWUqnPPnj3Y2NhQpkwZpk6dyogRI6hfv/5n9ZS5fv06Y8eOJTExkSVLljBjxgylavX398fMzIzk5GTq1q3LlClT6NmzZ4HVhM+ePcPFxYUdO3YQFBRElSpVcHNzo1GjRkrVumHDBhYtWoSmpibLli1j+PDh1KhR47PG+vv7Y2FhQVRUFLNnz2bBggUqrV9AaQoOqbQqh9KktSRQVJXVylw/Tps2jQMHDmBkZMTp06fFKpzs7GwmTpzIuXPnEASBKVOmsHr16jzjR40ahaOjI+PHj2fjxo1K0ylH0RwcPXo0Dg4O9OrVixMnTuT7LDNu3DjOnTsnyXP5ypUrWbVqFbVq1WL//v35Ohwo4vbt24wdO5bo6GiF7hnK4MPPNSwsjGnTpuHi4kLVqlWZNWsWkyZNkmRd+r/Ejz/+iL29vcIkLPn3ZsSIEezatSvP2OzsbIYMGcKNGzeYMGEC69evV6rWw4cPM3XqVMqUKcPvv/+OlZXVZ7kDJSQksH37dlatWkV2djY7d+5kxIgRStUKuefrpUuXmD59OpGRkXTq1Illy5bRoUMHpWv4HH777Td27dpFgwYNOH78eK5r+fTp09m/fz9t27bl3LlzeSogQ0ND6devH8HBwZJdB/766y/+/vtvtLS0uHTpUq7EdRcXF8aOHUtKSkq+eqRaI9y5c4d+/fqRnZ1Nt27dmDlzJiYmJgU+52dkZHDjxg02b96Mq6sr6urqODs7K71CLy4ujm7duhEaGoq6ujr9+/fPkyzycfDd19cXFxcXHBwcyMjIoGHDhri5uSn9GbaoUAUIVZQqVIEs5aDSqpiVK1dia2vLzz//zKRJk9DX11f6e34J8fHxdO3alZCQEBo3bsycOXMwMjKiQ4cO4o0+ISEBGxsbTp06haamJh4eHnks1FRaS6/WAwcOEBISwtq1a8nOzqZs2bK0aNECPT091NXVCQ4O5unTp6Snp6OmpsagQYMKrDjZtm2bUnQ+evQIDw8PRo0aVWLtROSUdK2nTp1ixowZosXFpxb1urq6ufqmzJ49mz///FMKqbi7u/Pnn3+KvWU+FcyWB6qHDRvG+vXrJVtUx8bGYm1tjZOTE/BpnfBvJmH//v3ZtGmTZNnapW2z9+jRoyxdupSwsLDPTmaQyWR07NiRvXv3oqenp2SF7y0kR48ejZOTk6hREIQCLflGjBjB06dPCQ0NRSaT0bp1a1xcXApV0fel3L59m/HjxxMRESHqVVdXR1tbW6xwyMjIICkpiYiICDIzM4H3n6u2tjb79+9XaFFc1KSlpdG3b18ePHgg6qxSpQrBwcH5jpk1axbPnj3D09OTrKws6tati7u7u9KvxaVJa2EoTdcLlVblUBK0Xrp0qUh+Tu/evYvk5xREYRPvFPGp+8fXYmhoSHBwsEK7eU9PT3r16oUgCPlaUT948IDu3bvToEEDHj16pDSdchTNQXmfYjc3N9q0aZPvWF9fX7p27SqJ1g4dOuDv71+gBX5BODk5MXLkSJo1a8bdu3eVoDA3ij7XQ4cOsXTpUiIjI6levTo///wz48ePl2QtVRANGzYsku9VQEBAESlSTIMGDXj37h0eHh55+vTJe6jfu3cv370hb29vTE1NqV+/Po8fP1aqVrnjzfLly/n1118LPX7Lli388ccffPfdd1y+fFkJCnPz8Xx99+4dc+fO5fjx48B7JwcbGxvJ7ITzo1WrVrx580ZhMq38mJOTU752vvLrQKtWrbh165bS9Xbu3JmnT5+yfft2/vOf/+Q5Lg8ka2hocPfu3TzOV1KtEf7zn//g7OzM6NGjv2i/ycrKiiNHjmBhYSH2VlYW//3vf9m6dSuNGjXi5MmThdrjCwwMZNiwYbx69Yrp06ezdOlSJSotOlQBQhWlClUgSzmotOZFfmN9/Pgx4eHhAFSsWJFq1apRpkyZfMcpexGoiNWrV7NixQratGmDg4MDlStXBhTf6H/55ReOHj3KhAkT2LBhg0rr/4jWt2/fYmxsTFhYGBMmTOC3337L8xAYFRXFmjVr2L59O0ZGRjg7O/9P9FH8v0xsbCynT5/m/v37REVFcfbs2XzP1dbWBqBbt25YWVlJ2hdDzsOHD7l06RLe3t68fPmS6OhoUlJSyM7OpmLFitSoUQN9fX06d+7MwIEDiy0pw8fHh7Nnz3Lz5k38/f15+/ZtnnNq1KhB06ZNMTY2ZsiQIbRu3VpSjSVhs7ewZGRk4OTkJM6BgIAA0tLScp2joaFBw4YN6dy5M4MGDVJ6hevHyGQy9uzZw4EDB/D19SUrK4v4+Ph8z9fR0SE5OZkyZcowdOhQbG1tJQ0MpaSksG/fPs6dO4eXlxfZ2dn5nlu2bFnat2/PkCFDGDdunCRBTDmpqamsWrWKgwcPEhsb+8m5K/9cATp16sT27dtp0KCBSusXUpquFyqtyqEkaC0NQTc5u3bt4uDBg3h7e3/Vzyno/vG11K5dm8zMTMLCwqhQoUKuY3FxcTRo0ABBEIiMjFTYdyo5ORkdHR3KlStHVFSU0nTKUTQHa9WqRVZWFtHR0airq+c7NjMzk1q1akmiVUtLi/T0dMLDw7/oPpmamso333xD+fLliYiIUILC3OT33U5LS2Pbtm1s3LiRuLg4ypQpQ48ePRgyZAgWFhaf5Y5Q1IwfPx4nJ6c8a7/CIMV1TD4HFH136tSpQ0ZGBrGxsfnuCWVlZVGzZk1J5mvdunVJTEzk9evXX/Q3lV8rpOifDfnP10ePHrFkyRKuXr2KIAg0btyYsWPHMnjw4Dw9oaVAfn1VdB2QH4uKisp3LyUtLQ0tLS0qVKgg7iUqE21tbVJTU/H396d27doKz+nfvz83b95k4MCBHDhwINcxqdYI8qQQHx+fL+rPGBwcjIGBAbVq1VJ6okCbNm0ICgrCwcGBrl27Fnr8zZs3sbCwoGHDhl+9lpAKVYBQRalCFchSDiqtefkca4aPKa4H765du+Ln55fn5qXoRv/06VM6deokSUabSqt0zJs3j23btjF9+nSWLVtW4LmLFy9mw4YNzJs3T2m9BuXkZ2VaEvlf1xoeHo6WlpbCvgMqCiY1NZXk5GTS09MpV64cFStWlDS4ogh5RVNxNGovShITE8UgcYUKFahSpUqJmaOZmZm8ffsWLS2tfM/ZsGEDdevWxcTEJN8HcqlIS0vj1atXhISE5JmvdevWpVGjRgo3iaXm9evXREVF0bFjx3zPmTVrFnXr1sXMzIxvv/1WQnW5+Ryt8oSc4tZaECtWrEAQBObPn1/cUj7JL7/8giAISnMyKEpUWgvH5cuXOXjwIBcuXBBf09bWLjAwpAgfH5+ilpYv8mRBQRBKnOW8np4eSUlJPHr0KM8Gek5ODo0aNUJNTY3AwECF48PCwmjRogUVK1YkLCxM6XoVPT/JN2BfvnxZYJ+m0NBQWrVqJUkQo0mTJsTExODt7f1FyR7yDezatWvz8uXLohf4EZ/a2E9ISGDr1q3s37+f8PBwBEFATU2Ntm3bYmpqipGREW3atPmizfovITY2lqlTp+Ls7IwgCGzdurXQAaDC2L5+CUZGRgQEBHDjxg0MDQ1zHWvbti2vX7/myZMn6OjoKBwvn69SBDHq1atHQkICr169+qIEtXfv3lG/fn2qVq1aoFtCUfGp+Xr79m2WL1/OzZs3xWddQ0NDunfvjomJCUZGRpIEt+VVgo8fP87zrNW0aVOioqIKDMrKP1epAq/yAGFERESenu5yfHx8MDExQSaT4ejoSJcuXcRjUgUIv/nmG9LS0r46AUOKwKs8GSC/JJtPkZ6eTp06ddDU1CQyMlIJCouessUtQIUKFSpKIg4ODsUt4bN59eoVQIEbWHLkvYakyGRShEqrcnB0dEQQBKysrD557pQpU1i/fj2nTp1SeoCwYcOG9OnTh379+vH999+X6B4YpU1r7969sbCw+Gyt8gpCFYWnfPnyxR4Q/JjSHhiUU7lyZbE6u6Shrq5eYHAQYObMmdKI+Qw0NTVp0aIFLVq0KG4pBdKgQYNPbrquW7dOGjGf4HO0rl27VhoxX8F///vf4pbw2fzzzz/FLeGzUWktHL169aJXr14cOnQIa2trBEHg3LlzJSro9jFz5sxh586dxMTEFLeUPDRp0gRvb2/Onz/P9OnTcx1TU1Pj9evXBY6/ceMGQB6rOWXzYZLbkCFD2LBhA8eOHSvQHvHEiROAcns6yvnuu+9wcHBg6dKl7Nmzp9Djly5diiAI+VoPSk2VKlWYP38+c+fOxdnZmQMHDnDlyhXu37/PgwcPAOkqcwFq1qzJzp07adq0KWlpaRgZGZW4a8CAAQNYv349Cxcu5PTp07kqBQcMGMCmTZs4cuQIs2fPVjhe3puwXbt2StfaokULPD092bNnD7/99luhx+/btw8gj5VqcdG5c2ccHBx48eIFe/fu5fjx4zx69IjHjx+LvVLr1aun9ITsbt26cezYMezs7Fi1alWuYyYmJpw6dYorV67k27dRnggjlRtOvXr1eP78OR4eHnz//fcKzzEwMGDChAns3r0bKysrPDw8qFSpkiT65DRo0EDsiT5gwIBCj7927Zr4c5RNjRo1iIiI4PXr1wX2eM+PoKAggBLVcuBTqAKEKlSoUKEAZWemFSXyzNv4+PgCsy8BMXuluDa7VVqVgzww+SmdgNgjTYpstt9//x1nZ2cmTpyImpoaXbt2xcLCgr59+6Krq6v09y8MKq3Fw+XLl3F2dhbtJmvUqMG3337LsGHDaNy4cbFqe/r0Kf7+/gQHB5OcnExqaioaGhpUqlQJXV1dmjZtioGBQbFoMzQ0pHz58qxcuVJyG87/K0RGRnL79m2Sk5OpX78+HTp0+GQGqaOjIwD9+vWTQmIe3r59K1YQpqSkiBWEenp61KlTp1g0FYaMjAy8vLyIiIigVq1adOjQoViD81lZWTx+/FicA58TmPf19QWQ3Hb4c5g/fz6CILBixYrilpIHecVraSMnJ4fY2FiqVatW6Eo4qSkpWn/88UdWrlzJmzdvik3D56KmpoaxsTHnzp0rbil5GDx4MA8fPuSvv/5CU1OT4cOHU6NGjc8a6+/vz8KFCxEE4Yv67H0NWlpa6Ovr06JFC3R1dREEgWXLlqGvr6+wv+SePXtYtWoVgiDkuxlflMyaNYtLly5x5swZgoODmTFjBt27dy9wIz0pKYlr166xadMmvLy8UFdX/6JgjTJRU1OjX79+9OvXj+joaC5fvoyrqyvXr18nOjpaUi1VqlSha9euXL16VdL3/VxmzJjByZMncXV1xdzcnIULF2JmZoYgCMyZM4cLFy6wevVqdHV1GTVqlDguKyuLzZs3s2HDBgRB4JdfflG61kmTJnHnzh2WL19OfHw806ZN+yxHi+joaLZs2cLmzZsRBIEpU6YoXWthaNq0KStXrmTp0qU4OTnh5OSEm5sbb968kaTScebMmZw7d05Mrpk/f77oMDZ37lwuXrzIH3/8wbfffpunN52npycLFixAEARGjx6tdK3wPgHn2bNn/P7775w5cybfqtzFixdz6dIlgoKCGDNmDCdOnJB07TVixAiWLl3Kr7/+Srly5ejVq9dnj71y5YqYXPTDDz8oUeV7TExMOH78OL///jvHjh0r1PNIeno6c+bMQRAEzMzMlCeyiFFZjKooVaisMJXD/3WtdnZ2JCQk5Kqmkj+IzJ07t8jeR1nI/cT/+usvrK2txdcVWQXs2bMHGxsbyRpRq7RKg9zq4tKlS3z33XcFnuvp6UmvXr2oWbNmvrZDRU1CQgKXL1/GycmJK1eukJCQgIGBgVixV5Js2VRaixZ9fX3U1NR4/vx5rtfDw8MZN24cd+/eBd5nlMuR2x9NnDiRFStWSNorMzAwkE2bNmFvb09sbOwnz69RowaDBw9m5syZklb1ya9DgiBgY2PD/PnzS/zmdGlB/lB36NAhcnJyxNdr167NH3/8wfjx4/MdW7VqVdTU1CTLxM/JyeHMmTNcuHABd3f3At+3SpUqmJiYMGzYMAYPHiy5pXJoaCj79u3D19cXQRAwNDTk559/Fjeyzp49y++//55ro7JChQrY2NgwZ84cSbUCrFmzho0bN5KYmCi+ZmBgwKJFizA3N893nNRzoDCUhD50b968wcHBQezxKg9oy+8B5cuXFxMwTExMGDhwYL42bspEJpNx48YNfHx8xPnarVs38fjLly9ZuHAhly9fJisrizJlytC1a1fmzZuXy7ZLpVUxkydP5sSJEyXOtlMRGzZsYN26dVy9erXYeiMrIi0tjb59+/LgwQPxel6lSpUCN89nzZrFs2fP8PT0JCsri7p16+Lu7i5JhUOPHj0IDAzMdW0UBEH87rds2ZLbt2+Lx3x8fPjhhx8IDw9HJpPRpUsXLl68mG/ft6Lk7NmzWFtbk5ycLK5J69evj66uLpUqVUJDQ4P09HSSkpLEgEVOTg4ymYxKlSqxbds2Bg4cqHSdUDTXdT8/P8kryBYvXsz69evx9PQskdcAf39/Ro8ezYsXLxAEgapVq9K2bVvq1atHYmIiZ8+eRRAE6tWrR8uWLcnIyODhw4fExcUhk8mYP3++0p165MhbjQiCQJkyZTA0NMTAwAAdHR1xvmZkZJCYmEhYWBg+Pj74+PiQnZ2NTCZj2rRpLF++XBKtXztfX7x4wbVr1yQJvtrb2zN58mRSU1OpUKECpqamtGvXjnr16vHgwQP++ecfypcvz5AhQ2jVqhWZmZl4enpy+fJlsrOz6dGjB2fOnJFkvR0dHU2XLl3Efq6mpqa0aNGCMWPG5Pl+eXl5MWDAAFJTU6lfvz4TJkxg0aJFkqwPMzMz6du3L/fu3UMQBFq0aEHPnj1p3bp1vtdXX19fXFxcePr0KTKZjM6dO3Px4kXKllVuvZu/vz9mZmYkJydTt25dpkyZQs+ePQusJpRXR+7YsYOgoCCqVKmCm5ub6DZW0lEFCFWUKv6vB7KUxf91rYq8sEvCJsrncuLECSZNmoSmpibr1q1jzJgxQN7fISAgAHNzc+Li4li3bh0TJ05Uaf0f0frzzz9z8uRJ2rdvj729PRUqVFB4XmpqKv379+f+/fv07duXo0ePSqwUsrOzuXnzJs7Ozjg5OfHq1Su0tbXp27cvffv2xczMTNKAUEGotH49iq6lSUlJdO/eHX9/fwC+//57jI2NqVmzJgkJCdy5cwcnJyeys7OxsLDg8OHDkmg9cuQINjY2pKenI5PJKFeuHE2bNkVHR4eKFSuKDyyJiYmEh4fj7+9PRkYGgiBQvnx5tm7dytChQyXRKv9cTUxMcHNzo0WLFmzevJkOHTpI8v7/q+Tk5DBkyBDc3NyQyWTUq1dP7CMUHx8vBmQXLVqkcLyUawc/Pz/GjRvHy5cvcwXYK1asKM7XtLQ0sfpVjiAItGzZkv3790u22X3u3Dl++eUX0tLSRK2CIKCtrY29vT1Pnz5l7Nix5OTkUKNGDXR0dHjz5g1xcXEIgsBPP/3E5s2bJdEK7624jx8/Ll4HqlSpIgYuy5Qpg62tLZaWlgrHluT1Y3FqS05OZu7cuRw7doysrKxcczY/BEFAXV2dsWPHilVSUuDv78/YsWN5+vRprtfNzMw4dOgQwcHBWFhY8Pbt2zxjy5Qpw8aNG/npp59UWgvgwIED7Nixg0OHDkliFfa/SmpqKqtWreLgwYPExsZ+8vuto6NDcnIyAJ06dWL79u2Sf/6xsbG8fPmSly9fEhAQIP5/uXLluH79uniei4sLw4YNQ0NDg3HjxrF06dJ8n2+UwZs3b9i8eTPnz5//rB6Nurq6DB48mGnTpklq61+S7zkFERsbS1hYGM2aNSsxz1Ifk5GRwb59+9i9ezfPnj0TX/8wsP0xHTt2ZN68efnaPCoLe3t7Vq9enatHq6LA1Ie627Rpw7x58yR1vSht89Xf359ly5Zhb29PTk5Ons/0Q8tk+b8rVKiAlZUV//3vf5UexPqQp0+fMnHiRJ48eQK8//vv2bNH4bPpjRs3GDt2rLjOlv8eUvxd0tLSWLhwIfv27SM9Pf2zAqgymQxNTU0mTpzI4sWLJat6vH37NuPHjyciIkLUqa6ujra2NpUqVUJdXZ2MjAySkpKIiIggMzNT1Kutrc3+/fs/mbxfklAFCFWUKv6vB7KUxf91rQYGBoSEhDBy5EhMTEwAsLKyQhAEtm3b9lmbGHKkshH4mLFjx3L+/Hlx469Tp07s3r0bQRBYvnw5Pj4+nD9/ntTUVIyNjbG3t0dNTU2l9X9E64sXL+jatSuZmZno6+szd+5czM3NxcbZ8fHxuLi4sHr1ap4/f44gCDg5OZWI/hhPnz7F0dERZ2dnvLy8KF++PN27d6dfv3707t37s2xTpUKltfAoehBctWoVK1eupGrVqhw9epSuXbvmGffo0SOGDBnC27dv2blzp9Jtpe7cuUO/fv3Izs6mW7duzJw5ExMTkwI3LTIyMrhx4wabN2/G1dUVdXV1nJ2dad++vVK1Qu7PdceOHSxevJiUlBRGjBjBokWL0NPTU7qG/0X279/P9OnTKVeuHNu2bWPYsGHA+03Y1atXs379egRB4PDhw1hYWOQZL9XGR0hICN26dSMuLo4aNWowbtw4zM3NMTAwEC2QPiQuLg4/Pz9cXFw4ePAgMTEx1K5dm5s3b/LNN98oVaufnx9mZmZkZGTQunVr+vTpQ5kyZXB2dubRo0c0b96ct2/fEhcXx4YNGxgzZoy4WbF//35+++03srOzOXXqVIGVe0XF+fPnGTt2LGpqaixcuJCpU6dSrlw5wsPDWbBgAadOnaJMmTI4OjrSqVOnPOOl3PwqbEayPIDwoQ2hIAgEBAQUtbRcpKWl0atXLx4/foxMJqN9+/aYm5tjaGgoVjioq6vnSsDw9fXl6tWrYpa5kZERTk5OSt9IjomJoWvXrkRERFC+fHnatGlDmTJl8Pb2JiUlhf79+xMSEoK3tzcjR45k2rRp6OnpERISwsaNGzl58iQaGhq4u7sr/bmqNGlVoXxev35NVFRUgb3Tf/vtN/T09DAzMysRLhMF4e/vL67N5O0RiouAgAD8/f0JDQ0lOTlZtESWW3g3bdq02CpEfvnlF3HPQoXykF9LX758SXR0NCkpKWRnZ1OhQgVq1qyJvr4+nTp1Kvae7wEBAWKFfmhoKElJSWRkZIgtEuTz1djYuFjmbOvWrVFTU1N6D8GiJiYmhsuXL4tzICYmhuTkZLKzs6lYsSI1a9akSZMmdO7cmV69eilci0vFtWvXcHV1JTAwECsrK4XP2fC+LcGOHTtwcnLCz8+PrKwsSQO30dHRODo64u7u/snra7du3ejXr1+x7LWkpKSwb98+zp07h5eXF9nZ2fmeW7ZsWdq3b8+QIUMYN25csbZJ+BJUAUIVpYr/64EsZfF/XevKlStFS9GvpbiyobKysli2bBl2dnZiRcuHWfryrKCRI0eyZs0ayRsSq7QqH2dnZywtLUlKShLncqVKlRAEQbRIk8lklClThpUrV5a4XgPwfvEt7zPg6uoqNq+3sLBg+PDhJSroodL6eSjaLO/UqRPPnj1j/fr1TJgwId+xhw8fZurUqZiamorN3pXFf/7zH5ydnRk9evQXbbJYWVlx5MgRLCwsOHLkiBIU5ubjz/XVq1dYW1vj4eGBhoYGo0ePZvr06cXexxHgzz///OqfIQgCS5cuLQI1BdOnTx/u3LnD/PnzFVqM//HHH2zZsoU6derw4MEDKleunOu4VMGh6dOns3//foyMjDh58mShNk/fvXvH0KFDefDgARMmTGD9+vVKVPpvhbuFhQUHDx4U7eFycnL48ccfcXBwQBAEpk2bxrJly/KMnz9/PnZ2dpJ9twYNGoSbmxuTJk3C1tY2z3FLS0tOnTpFw4YNuXv3bp6AlZQBwnr16hEfH/9VP0MKrfJ1dq1atdi/f3+h+nzfvn2bsWPHEh0dzR9//KF0u1n5d7xFixacPHmSunXrAu+riUaMGCFm5vfr10/hfPzhhx+4dOkS48aNY9OmTSqtKlSoUKFChYoSTVZWFlFRUcVi6V6aSEtL49WrV6I9/ofBzLp169KoUaNS2U9bjipAqKJU8X89kKUs/q9rlclk7Nq1i+vXr4sbLTdv3kQQhHwzbvLDwcGhyHR9CdHR0Zw7d46HDx8SFRVFdnY2NWrUwNDQkP79+5eIzWI5Kq1FT2hoKGvXruX8+fN5+qeVL18ec3NzZs2aRbt27YpJ4eeTnp7O9evXcXJy4tKlS4wfP16yXg6FRaU1fxRtlsttnQMCAgoMbLx9+5aGDRtSrVo1goKClKYRoHHjxsTGxuLj4yNushaG4OBgDAwMqFWrltKrcSD/IIS9vT3Lly/n2bNnqKmpYWpqyrhx4+jTp0+xZTHWrl1btFz5EqS0valXrx4JCQl4e3srtF3LyMigQ4cOBAUFMXPmTBYvXpzruFTBoZYtWxIWFoarqytt27Yt9PiHDx9iZmaGnp4efn5+RS/wA5o1a0ZkZCQeHh55ehw9efKEzp07IwgC9+7dU2h5+vz5czp27EidOnVEW2Jl0qBBA969e5evnsTERNq1a0d0dDRLlixhxowZuY5LGSCMiIjgl19+4fr16wiCwMSJE/O1OZbJZPTv3x9BELh48WKuY4UJ2H0JHTp0wN/fn6NHj9K3b99Cj3dycmLkyJE0a9ZM7FurLNq1a0dgYCDnz5/H1NQ01zFXV1cGDRqEIAhcvXoVIyOjPOPv3r1Lz549qV+/vtIrJEqT1v9VPDw8AAr9vCg1pUUnlC6tKv5vk5OTQ0REBGlpadSoUUN07lGRPyEhIZQrV446deoUtxQVKlR8hCpAqKJU8X89kKUsVFrzUtr80VWo+Jjg4GCio6PJysqiRo0aNGrUSKzcKI3Ex8cXq11HYVBp/RdF19K6deuSmJhIVFRUgXZxKSkpaGtro6GhIfb/UhaKetEWhtTUVL755hsqVKhAeHi4EhTmpqB7lEwm49ixY6xatYrXr1+LPRK///57unfvjomJiWS95wASEhI4evQoq1at4u3btwiCQL9+/Qo976Swz5IHM6Ojo1FXV1d4zsWLFxkzZgyampp4eXnlCihLtXaoU6cOGRkZREZGflGmanp6OnXq1EFTU5PIyEglKPyXWrVqkZWVRURERJ4ecvLvjSAICo/D+2xdLS0t1NXViYmJUarWD/UWNAcOHDjAtGnTqFq1Kg8fPsyV6FAc68cdO3awaNEiUlNTGT58OGvXrlX4/Squta2Wlhbp6elffX0tX748ERERSlD4L/LvVmhoaB5XiOTkZHR0dBAEgTdv3lCxYsU84xMTE9HT06NcuXJERUWptH4B8mrH4mrbUBiqVq2KmpoacXFxxS2lQEqLTihdWlUUnpycHG7cuIGfnx8ymYxWrVrRvXt38bibmxvr1q3D19eXpKQkdHR0+P7775kxY8YXJfB9KVevXgVQ2EvwyZMn/P3337i4uJCUlCS+Xr9+fX744Qesra2LJViYmpqKm5ubaDEaEhJCUlISqampYpWTrq4uTZs2xdTUlO7du0vW21eO/Ps9a9YsFixYUCQOXirek52dzaVLl0RXmQ8JCAgQW2KEh4ejoaFB48aNGTBgAJMmTaJKlSrFojkhIYFbt27x8uVLgoODSU5OJiUlJY/FaNeuXUtMAP7t27diBeHHWkt74Fu6jpkqVKhQUYqYO3fuVy9Y/v77bywtLZXeN0G+0IqMjCyxTb7lqLRKR7169ahXr57Yd6CksGrVqiL9ecqsflNpVQ5GRka4urri4+OjsKpBzqNHj4D3m8vKpkGDBjx79gwXFxcGDBhQ6PHXrl0Tf05xIwgCo0aNYuTIkVy+fJkDBw5w6dIl7O3txcqhKlWq0KZNG+zt7ZWup0qVKkyZMoUOHTqIm0ALFy4skUlJWlpahIaG8vz5c1q3bq3wnP79+2NqaoqbmxvW1tZKt79VhJaWFiEhIfj6+hb4HcoPufWgFA+y1atXJzo6mqCgIJo1a5brWHBwsPj/YWFhCvvhyAPuH9u5KotatWoRERFBUFAQTZo0UXjOTz/9xK5du3j8+DGzZ89m7969kmjLj8mTJ9O9e3cmT57MyZMnuXXrFlu2bKFHjx7FqktO5cqVSU9PJzIy8ouukfIEESls3DU1NcnIyODdu3d53u/DwGpiYqLCoFtKSgqAJOuu0qS1MFhZWaGmplYqAoRAoXrVFyelRSeULq0qPh8fHx/GjRtHYGBgrtfbt2/PyZMnuXPnDj/++CPZ2dniHAgMDOTVq1ccO3aMQ4cOYWZmJonWoUOHKgxUnzx5EmtrazIyMvLM09evX2Nra8uRI0c4ceJEHtcEZZGTk8OaNWuws7MTr/35fYeePXvGtWvX+Oeff6hevTo2NjZMnz5dEp1ycnJyWLt2LR4eHtjZ2RVb/87/JR49esTEiRMJCAjAwMAgV4Dw7NmzWFlZkZaWJs6LtLQ0Hj58iLe3N3v37uXo0aMYGBhIpvfWrVvY2tpy48YNsaefojkr348tU6YM3bt3Z+7cuXTo0EEynfB+vp45c4YLFy7g7u5eYPJKlSpVMDExYdiwYQwePLjUBcBVAUIVklHYbMCjR49StWpV+vXrJ742d+5cateurRR9H6LSqhxKk9b//ve/X/0zVq9ezcCBA5UeIKxXrx4hISEEBATQokULpb7X16LSqlyysrLYs2cPFy9e5NmzZ8TExCCTyYiLi8Pf35/du3czZcoUGjZsWGwaV65cWajFktxeML/XlRnIUmktOtasWUPz5s1p0aIFU6dO5fr16yxYsIALFy4orNJJTk4WM0u7detWpFoUMWLECJYuXcqvv/5KuXLl6NWr12ePvXLlCtbW1giCwA8//KBElYVDEAR69+5N7969iYmJ4ejRozg7O3P37l3i4+Nxd3eXVE+7du0wMDDA19dX0vctDF26dOH48eMsXryY48eP51t1vW7dOoyNjblx4wZLlixh0aJFkurs2bMnu3fvZubMmZw+fbpQgb7o6GhmzJghzg9l07lzZy5cuMDq1avZs2dPrmOrV68W///ChQvMnDkzz/izZ88CYGhoqFSdcjp06IC9vT1r1qzhn3/+UXiOIAhs2LABc3Nzzp49S5cuXZg0aZIk+vJDX18fFxcX/v77b9asWcPQoUOxtLRk+fLlxWYvLOe7777DwcGBpUuX5pkDn8PSpUsRBIHOnTsrQV1uDAwM8PDw4OjRo3n6HR49elT8/1u3bim0c5VfV/MLLhclpUlrYVEFiFSo+N8iPDycgQMH8vbtW8qVK4eBgQGVKlXCx8cHLy8vbGxsePDgAVlZWQwaNIhRo0ZRq1Yt/P392bp1K76+vowdO5bbt2+jq6srieaPr0N+fn5YWVmRmZlJy5YtmTNnDsbGxtSsWZP4+Hg8PT1Zs2YNXl5eDB06lDt37lC9enWlaszJyWH48OFcu3YNmUyGtrY23bt3x8DAAF1dXSpWrIiGhgZpaWkkJSURFhaGn58frq6uhIWFsXDhQu7cuSNJj2c58ufMNWvW0KVLF+bNm4e1tXW+rg0qCubVq1cMGDBAdAX68BnWz8+PyZMnk5GRQaNGjZg2bRrNmjVDU1OT+/fvs2XLFoKCghg2bBi3b99W+r4lgK2tLStWrCAnJwd4v+dmYGCAjo4OlSpVQl1dnfT0dBITEwkPD8fPz4/g4GCuXLnCtWvXxOd1KfDz82PcuHG8fPky1/WgYsWKub5bycnJpKamEh8fLybk2trasn//fklde74WlcWoCskorF1EvXr1UFNT4/Xr18oVpgCVVuVQmrQWBVLZoe7YsYM5c+YwefJkbG1tlfpeX4tKq/IICAhg6NChBAUF5VrAyO3E5D2nKlSowM6dO+nfv3+x6Dxw4AAhISGsXbuW7OxsypYtS4sWLdDT00NdXZ3g4GCePn1Keno6ampqDBo0qMDNTWXaDqq0fj1ym7sPg5HyqoecnBwGDBjAwYMHxWPJycmcOHGCzZs3ExAQQLly5XBzc1N6kD4zM5O+ffty7949BEGgRYsW9OzZk9atW6Orq0ulSpXQ0NAgPT2dpKQk3rx5g6+vLy4uLjx9+hSZTEbnzp25ePEiZcsqP//ua6wCU1NTcXd3x9XVlRUrVhS9uAKwsbFh79693Llzp0RWEPr6+mJmZkZWVhZNmzZlzJgxNG/enPbt2+d5aD506JAYGB4yZAjW1tZ8//33klg4RkZG0qVLF2JjY6lcuTKjRo3C3NwcAwMD0bJTjrxHjo+PDy4uLhw/fpz4+Hi0tLTw8PBQetLV/fv36dmzJzk5OXz33XdYWFggCAIODg7cuXOH+vXr8+7dO7Kysjh+/Hiufniurq6MGjWK1NRUduzYIUkA3sPDg379+iEIAmZmZowbN44WLVpQv379PNdMW1tbli9fjpqaGjNmzGDq1Kno6+sXu0X9/fv3mTx5Mi9fvqRx48Zs376dDh06FJvF6P379+nduzdZWVm0b9+eGTNm0L179wIrApOSkrh27RqbNm3Cy8sLdXV1rly58kU9NwvD6dOnmThxIurq6kyfPl3s22hvb8+mTZvEjSs9PT2uX7+e67oQHR1N9+7dCQ0NZdGiRdjY2Ki0fgGlqc1DadFaWnRCydD67NmzIvk5Uqxz5JXAX0uFChWK5Ofkx7x589i2bRv6+vocP36cxo0bA++v9SNHjuTmzZvA+4S9nTt35hqbnZ1Nv3798PT0ZOrUqZKsXRXNQ0tLS06dOkWHDh24ePGiQnvO7OxsBg8ejLu7O7NmzWLhwoVK1WlnZ8f8+fOpUKECa9euZeTIkaipqX1ynEwm48SJE9jY2JCSkoKtra0kiU4ffq6PHz/GysoKX19fGjZsyMKFC/Pto6wif6ZMmcKxY8do27YtJ0+ezJU0KJ+zPXr04MSJE3mCsImJifTr1w8fHx+mT5/O0qVLlapV3lMaYMyYMdjY2HxWAM3f359NmzZx4MABBEHg1KlTmJubK1VrSEgI3bp1Iy4ujho1ajBu3DjxWUuRjX9cXBx+fn64uLhw8OBBYmJiqF27Njdv3uSbb75RqtaiQhUgVKE0QkJCclkHyR+2HR0dP5kVGBwczNSpUylXrpzSe02ASquyKE1alYGUvR1XrlyJra0tP//8M5MmTSrRmSoqrUVPfHw8Xbt2JSQkhMaNGzNnzhyMjIzo0KGDuAhPSEjAxsaGU6dOoampiYeHR7Fkjb99+xZjY2PCwsKYMGECv/32G3p6ernOiYqKYs2aNWzfvh0jIyOcnZ2LxQJLpfXrcXFx4eXLl+J/AQEBhIaGilmDLVu25Pbt27nOHzZsGPB+s2Lbtm0MHjxYqRrlpKWlsXDhQvbt20d6evpnVWTKZDI0NTWZOHEiixcv/qJ+cF9CSdhA+xJu3LiBo6Mjv/32myRuAF/CqVOnmDZtGikpKeIc2LNnj8JNi/Xr17NkyRLx3/IKXCn+Lv7+/kyYMAEfH59cc1VNTY0KFSqgrq5ORkYGqamp4vdNrrFNmzbs3btX3KBTNgcOHMDGxoasrCxRq0wmo2bNmjg4OHD//n0x2NqmTRt0dXUJCQnBx8cHmUxGjx49xEpCKdi0aROLFi0iJyfnk3PAxsaGPXv25Pq9SsJ3My0tjQULFrBr1y7U1NSYOXMma9euLTZtZ8+exdramuTkZARBQE1Njfr16+ebgBEcHExOTg4ymYxKlSqxbds2Bg4cKInWqVOncvjwYYX3gP3793P37l22bNlC7dq1+c9//iPO1+PHjxMbG0uDBg3w8PCQxBK1NGn9XErT/a20aC0tOqFkaJVr+BoEQZCkj2Jp0WpkZERAQACnT5/O09fvxo0bDBgwAEEQuHHjhkLHAHnyTtOmTbl3755StYLiedisWTMiIyNxdHSkS5cu+Y719PSkV69eNGvWjLt37ypVp7GxMb6+vtjZ2X2RLfPhw4eZOnUqbdq04caNG0pQmJuPP9esrCxWr17N5s2bSUtLo0mTJsyYMYPhw4cXu/tBUdjZCoLA9evXv15MAejr6xMdHc3ly5fp2LFjrmNNmzYlKioq3+8VwM2bN7GwsKBJkybcv39fqVoHDBiAu7s7M2bMyPX89LksXryY9evXY2Zmxvnz55Wg8F+mT5/O/v37MTIy4uTJk4Wqrnz37h1Dhw7lwYMHTJgwgfXr1ytRadGhChCqUBorV67MZR1UWGQyGR06dMDFxaUIVSlGpVU5lCatykCqAOF//vMfAB4/fiz26qlYsSLVqlXL1x5Nfr7UqLQqh9WrV7NixQratGmDg4OD2KtJ0cPNL7/8wtGjR5kwYQIbNmyQXKs8g3T69OksW7aswHMXL17Mhg0bmDdvnlLtOfNDpVU5ZGRkEBAQwMuXL0lISGDMmDHiMRcXF2bMmMHAgQOxtrbOE+SUgujoaBwdHXF3d8ff35/Q0FCSk5NJT0/P0zS9W7du9OvXj1q1akmqsSRsoP0vExISwt69e7l+/TqBgYFs3Lgx30D1jRs3+Pvvv/Hw8BADSlL+XRwdHTlz5gw3b94U71WK0NHRwdjYmKFDh9K3b1/J9Ml5/vw5e/bswcfHBzU1NQwMDJg6dSp169YFYOvWrSxZsoT09HRxjCAIjBw5kvXr10u+UeTl5YWdnR1ubm7ExMSwd+/efDPbDx8+zOrVqwkKCgIoUd/Na9euMXXqVCIiIoo9ePnmzRs2b97M+fPnCQsL++T5urq6DB48mGnTpqGtrS2Bwn/Zu3cvu3bt4smTJwiCQKtWrfjjjz/o06cPGRkZjB8/HgcHh1wb8zKZjMaNG3PixAlJE7BKk9bPoTTd3+TJrw4ODsUtpUBKi04oGVp37drFwYMH8fb2/qqfEx8fXzSCCmDhwoWcOHGiwPv/56BsrXXq1CEjI4OQkJA8PYVjY2Np1KgRgiAQFhamsJoxISGBunXrUr58eUmSxxVdh2rVqkVWVhaRkZEFJgSmp6dTp04dSbRqa2uTmprKmzdvFPaa/RRJSUmiFenn3Je/lvyu7xEREaxevZqDBw+SlZVFlSpVGD58OEOGDMHY2LhYerl1796dBw8efNXPkOJeJv9uKZqXtWvXJjMzk5iYmHwdbjIyMqhduzaamppERkYqVWv9+vWJj4/H39//ixJFo6Ki0NfXp1q1auKaW1m0bNmSsLAwXF1dv8i9Qu7epaenh5+fX9ELVAKqAKEKpWFnZ5fLoiw4OBhBEMSNgIIQBIEGDRqwatUqWrZsqUyZgEqrsihNWpWBVAFCRSXun6K4HrxVWpVD165d8fPzw8HBga5du4qvK1qEP336lE6dOlG/fv1iCWYaGhoSHBzMkydP0NHRKfDc8PBwmjdvjr6+Pl5eXhIp/BeV1q8jvz6HBZGTk/NZ1jgqVJQ04uPj8fX1JTQ0VEwwkTEJzYQAAQAASURBVJrk5GRCQ0NJSkoiIyMDDQ0NKlWqhJ6e3hdtHElNVFQUV65cITIyklq1amFiYkKDBg2KWxaJiYmoq6srtBP7kCdPnuDt7c2bN2/y9IQrTt69e8eff/5JYGAgQIkIEgQEBHwyAaNRo0bFLVOsvlV0X7p48SIODg5ERERQq1YtzMzM+OGHH4qtj1Jp0loQv/zyC4IgKNWWXYWKz0GegCkIQom1Rof3G/xz5sxh3759CILA2bNnC+0QUK9ePSWpe4+Ojg4pKSk8ffo0T8JHdnY2NWrUKPA5Ojo6miZNmhRrgLBVq1a8efOG169fU61atXzHRkZG0rRpU0mCbg0bNiQuLo5nz559kY2hPOBSvXp1Sdr6fCoB5PXr16xevZozZ86QlpaGIAjUqFEDExMTTE1NMTIyomXLlpK0c4D3Peh+/fVXHjx4gCAILFiwoNAJSx8mwioD+R7AvXv38rhdtW7dmtDQUF6+fJlvMqv8uyXFHNDV1RWfVb7EuUAe0K5UqRJv3rxRgsJ/KSjw+jnIEwWkCLwWFaoAoQrJKE3ZgCqtyqE0aS0KpAoQyj37C8uHfX6kQqVVOcgfuqKjo3Nt9ij6zskXKxoaGkRHR0uuVZ7JFhUV9Ul7Sykz2hSh0vp1NGjQgN69e2NhYcH3339fKgIUKlSoUKFChQoVKlTk5OTQtGlTYmJiSnSAEN4/3+nr65OQkFAitXbu3JmnT5+yefNmfvrppzzHk5OTAfJ9VnB0dGTUqFGSJWIqeoaW99HeunVrgUGfvXv3MnPmTElsOwcPHoyrqytTpkz5Iueu//73v2zdupXvv/+eM2fOKEFhbj53P/Ddu3ccPXqUgwcPitVX8qRTDQ0NoqKilC1VJDIyklatWpGVlVUiv1u//fYbu3btYvjw4ezevTvXsZkzZ7Jv3z7Wrl2LpaWlwvGbN29mwYIFdOvWjYsXLypVq6mpKY8ePWLjxo2MGzeu0OPl/d+//fZbXF1di17gBxgYGBASEsLVq1cxMjIq9Hh5BWG9evXw8fFRgsKiR5qwuwoVwKhRo4qlNPxLUGlVDqVJa2miOAJSX4pKq3KQBwXj4+M/aXUoDwgVl69/9erViYqK4uHDh3z33XcFnvvw4UMg/4dFZaPS+nX8/vvvODs7M3HiRNTU1OjatSsWFhb07dsXXV1dpb63ipLJu3fvkMlkVK9ePdfrmZmZnD17Fl9fXxITE9HV1aVHjx60a9euWHTGxsby4sULOnfunOv17Oxszp49i5ubG2FhYWhoaNCkSRP69+//ye+dsklMTCQgIICQkBCSkpJITU0VK7J0dXVFS57ioH///pQvX54lS5aUGleInJwcgoKCaNiwYZ5jd+/ezTMH+vTp81kOGcVBeno6r1+/Fr9bUtt1FkRcXBzJycmkpqaKFa+F6fMiBbGxsSQlJaGnp1egxbychIQEAKpUqaJsaXkoTVpLA6mpqbi5uXHz5k38/f3zvb42bdoUU1NTunfv/slKY2UQEBDAhQsXuHPnDv7+/sTGxpKcnEyZMmWoWLEitWrVQl9fn7Zt29K7d+98e1FJwatXr/D19UUQBFq3bp2rSjwmJoY1a9bg6OgoVpJ3796dmTNnFosVrpqaGsbGxpw7d07y9y4s5cqVw9jYGEdHx+KWopC+ffvy5MkT/vjjD2rXrk2fPn1yHS/omSQ2NpY//vgDQRAwNzdXttRctG3blhYtWtCiRQvRBvW///0vrVu3pk2bNnnOd3FxYdGiRQiCwKBBg5Sub9q0abi6urJ9+3YiIyOZOXPmZ9khent7s2HDBs6dO4eamhozZsxQutbCUK1aNaysrLCyssLb2xsnJydcXV3x8vIiIyNDUi1aWlp06tTpi5PHlY2NjQ2nTp3i9OnTpKWlsWTJEvF6OW/ePM6fP8+iRYto3rx5LqcpgNOnT7N06VIEQWD8+PFK1/rTTz/h7e3N77//TmZmJuPHj/+satCsrCz2798vXge+JLhYWHr27Mnu3buZOXMmp0+fpk6dOp89Njo6mhkzZiAIAr1791aiyqJFVUGoQoUKFUpCGRWEdnZ2JCQk5OobtmrVKgRBYO7cuUX2PkWBSqt09O/fn5s3b/LXX39hbW0tvq4oS2/Pnj3Y2Njw3XffcfnyZcm1/vzzz5w8eZL27dtjb2+vsM8EvN+U6d+/P/fv36dv374cPXpUYqUqrUVFQkICly9fxsnJiStXrpCQkICBgQF9+vShX79+fPvtt0rXoKL4yM7OxtbWlv3794s9crS1tZk9ezaWlpZERETQv39/Xr58CeS2pu3Tpw/bt2//IsvnLyE+Pp758+dz4sQJWrZsmSvz+8WLF4wZMwZ/f39RJ5BL6z///CNpEC4+Pp7du3dz/vx5Hj9+LGrKD0NDQ4YNG4alpeUXWft8KfJ7kaamJqtWrZJkE+JLyczMZO3atezcuRNdXd1ccyAqKoqff/5ZYUVAmTJlsLS05K+//pLUtjEwMJDDhw/z5MkTZDIZrVq1wtLSUrSaXrVqFVu3biUxMVEc07x5c/744w8GDBggmU45d+/e5cKFC7i7uxMQEEBSUlKeczQ1NWnSpAkmJiYMHTqU9u3bS64T4MSJE9ja2orf+TJlytC7d2/mz5+PgYFBvuOqVq2KmpoacXFxUkktVVpLAzk5OaxZswY7OztxDV3Q9VV+H6hevTo2NjZMnz5dCpkkJiYya9YsTp06hUwm++Q9QK6zffv2LF26lC5dukghE3gf/Pvll19wcXHJ9fpPP/3E+vXriYiIwMLCgqCgoDy/R4UKFdi3b1+xbLRu2LCBdevWcfXq1Tz2fSWN5cuXY2tri6enZ4mrcnr37h2mpqa8fv0aQRCoUqUK9erVKzDosn79ep4/f46joyPx8fFUr16dW7dufbKVQlHQpEmTPE47giCIa1QDAwPc3d3FY/7+/lhZWeHl5YVMJqNZs2a4ublJkpC7detW/vzzT9FmumbNmrRu3Vq0YtTQ0CA9PZ2kpCTCwsLw9fUlNjYWmUxGmTJlWLFiBb/88ovSdcLXO4olJSXh7u4ueS/tP/74gy1btpTI7xaAp6cnY8aMITo6WuxF3K5dO+rVq0dISAj79+9HEAS6du1Kq1atyMzMxNPTU1w7/vjjj2zdulUSrT/++CP29vYIgkD16tUxNTWldevW6OjoULlyZdTV1cnIyCAxMVGcr25ubmKS6ZAhQ9i3b5/SdUZGRtKlSxdiY2OpXLkyo0aNwtzcHAMDA7755ptchS85OTlERETg4+ODi4sLx48fJz4+Hi0tLTw8PL6o32JxoAoQqpCcyMhIvLy86Nmzp2iDlpiYyOLFi3FzcyMnJ0d8oCnubEaVVpXWr0EZAcJvvvmGtLQ0wsPDxQVnSbVuVWmVjhMnTjBp0iQ0NTVZt26daHvy8e8QEBCAubk5cXFxrFu3jokTJ0qu9cWLF3Tt2pXMzEz09fWZO3cu5ubm4qZ6fHw8Li4urF69mufPnyMIAk5OTnkqeVRaS6fW7Oxsbt68ibOzM05OTrx69QptbW369u1L3759MTMz+6RFqorSQ05ODiNGjODq1at5NvwEQWDt2rVcuXIFJycnqlatiomJCbVr18bf3x8PDw9kMhkdO3bEycnps6phvoakpCR69eolPiybm5tz+vRp4P3GprGxMeHh4airqzNgwACaNWtG+fLlefDgARcvXiQ7O5sOHTrg6OgoSYDo+vXrWFpa8vbtW/GzrVq1Kjo6OlSsWBENDQ3S0tJISkoiPDxcDBAJgkCdOnXYt2+fZJvD8ntR06ZNefHiBWZmZmzevLnEVdxlZWUxbNgw3NzckMlkGBkZce3aNeD9/OjRowcvXrxAJpPRvn17mjVrhqamJg8ePODhw4cIgiBpksjhw4eZOXMmmZmZuQLWNWrUwN7eHmdnZ5YuXSqer6mpSVpamnjeokWLsLGxkURrREQEkydPFoOrnwpkwL/BjJ49e7Jt27ZPOiQUJUuXLmXdunUKdZYvX569e/fmu0Ep9fqxNGktDeTk5DB8+HCuXbuGTCZDW1ub7t27Y2BggK6ubp7ra1hYGH5+fri6uhIWFoYgCPTr148jR44oVWdGRgbff/89Pj4+qKurM2zYMDp16oSGhgaPHz/m8OHDJCYmMnPmTIyMjAgKCuLBgwe4uLgQHx9PmTJl+Pvvv/n555+VqhPeXz+7d++Ov78/MpkMHR0dypQpQ0hICIIgMHHiRAICAnB1daVbt25MnToVPT09QkJC2LJlC7du3aJy5crcvn27xN03ShKZmZmkpKRQpUqVEunaFBUVxe+//469vT1ZWVmfvPbIW2jIZDLq16/P3r17v8jq70tJSkrC39+fly9f5vovMDAQPT09bt++LZ7r4uLCsGHDAOjduzdbt26VNCjw8OFDbG1tuXLlSp4KO3lg80PKlStHr169mD179mdVHBYVpfWe8+rVK548eYKZmVmJbZkRGxvL+vXrOXDgAPHx8cC/66gP//4fzgcdHR3mzp0reeLeli1b2Lhxo2gVW9D1Sq5VS0sLGxsbrKysJNEI7wP/EyZMwMfHJ5dGNTU1KlSoIAYzU1NTxQC9XHObNm3Yu3dvofvBFieqAKEKSVm+fDnr168nJyeHFy9eiDfNAQMG4O7unuvhtm3btri4uEjWgFalVaW1qFFGgFDuhT1y5EhMTEwAsLKyQhAEtm3b9lkbLnJGjx5dZLoUodIqLWPHjuX8+fMIgkDLli3p1KkTu3fvRhAEli9fjo+PD+fPnyc1NRVjY2Ps7e1RU1MrFq3Ozs5YWlqSlJQkLrYqVaqEIAjiJrY8q3HlypVMmTKlWHSqtCqfp0+f4ujoiLOzM15eXpQvX57u3bvTr18/evfuLemGsIqiR96HRUNDg9mzZzN06FAqVaqEh4cHs2fPJiMjg5SUFPT19Tl//nyurPB79+7xww8/EBcX98W9KgrDkiVLWLduHbVq1WL79u25bKzkPVoaNWrEyZMn81idPXr0iCFDhvD27VtWr16t9O/WkydP6NGjB6mpqejr6zN16lTMzc2pV69evmOCg4NxcXFh+/btPHv2jEqVKuHq6ipJRYR8QygqKoqlS5eydetWypUrh7W1NbNmzSoxmy0bNmxg0aJFVKhQgb/++ovRo0eLdoGrVq1i5cqV1K5dm71799KtW7dcY52cnJg4cSKpqan8888/jBw5UqlaHzx4gLm5OdnZ2TRt2hQLCwvxu3Xt2jUMDQ15/fo1GRkZLFu2jFGjRlG5cmVCQkJYv349e/bsQRAErly5ovQKvbi4OLp160ZoaCjq6ur0798fc3NzDA0N0dHRESscPgy4+Pr64uLigoODAxkZGTRs2BA3NzdJEgfd3NwYOHAggiAwYcIEbGxsqFOnDt7e3ixduhQPDw80NTVxc3NTuMaXcgO0NGktLdjZ2TF//nwqVKjA2rVrGTly5Getl2UyGSdOnMDGxoaUlBRsbW2ZNGmS0nSuW7eOJUuWULt2bc6dO0fr1q1zHQ8ODqZv377ExcVx8+ZNGjVqBEBKSgrr1q1jzZo1lClTBkdHR6VbZMuvn3p6ehw4cEAM8nh7e/Pjjz8SGhoKvO9T5+jomKcyo3fv3ty7d49ffvmFVatWKVWrCuUTHx/Po0ePiIqKYvjw4fmeN2LECPT09DAzM8PCwqJE7QnFx8fncreQP2cPHjw4z3dRSlJSUvD09MTf35/Q0FCSkpLIyMgQLbz19PRo2rQpHTt2zNdtRpn069cPQRBwcHCQ/L3/r5Cdnc2dO3d4+PAhAQEBREdHk5ycTE5ODhUqVKBmzZro6+vTqVMnOnbsWGzJBBkZGXh4eODu7s7Lly8JCQkhOTmZ9PR00cK7bt266Ovr061bN7p27SqpQ8eHODo6cubMGW7evCm64ShCR0cHY2Njhg4dKnmVa1GgChCqkIzTp0+L1Sp16tTh7t27VK9enZs3b2JhYUH58uVZuXIl6urqLFiwgHfv3vH3338zefJklVaVVsm1FgXKCBCuXLlStL78WpS9GaDSKi1ZWVksW7YMOzs7MjIycmWHfWiJMnLkSNasWSOpvZwiQkNDWbt2LefPnyc2NjbXsfLly2Nubs6sWbOKrQfZh6i0SkNMTAxOTk5in4m0tDSMjIywsLBg+PDh6OnpKfX9iyIAJQiCJLYnpUVr79698fT0ZPHixcycOTPXsYMHD/Lrr78iCAKHDh2if//+ecbv27ePGTNm0LVrV6X31Wnbti2vX79m3759DB48WOGxEydO0KtXL4Xj5ZXc7dq14/r160rVOnHiRE6fPk3Pnj05cuRIoapus7KyGDVqFJcvX+aHH35g586dSlT6no+DEJ6enlhZWREQEEDNmjWxtrZm0qRJxe4a8d133/H8+XM2bNiQJ5u6U6dOPHv2jN27d4tVAh+zc+dOZs+eLcl8nTBhAmfOnKFnz54cPXo016bJrFmzxAShefPm5bJPl/Prr79y8OBBRowYwa5du5Sq9VMB9oIIDAxk2LBhvHr1iunTp+eqiFQWo0aNwtHRkWHDhrFnz55cx+RVpq6urrRt2xZXV9c8a0cpg26lSWtKSkqR/Bxlb2obGxvj6+uLnZ3dFyX9HT58mKlTp9KmTRuFdsRFhVznzp07GTFihMJzzp8/z9ixYxk5ciTbt2/PdWzp0qWsXbuWwYMHs3//fqXphPeBv6dPnyq811+8eJExY8YgCAIXL15U2APe1dWVQYMGoa+vj5eXl1K1qlChQoUKFfmRnJycb/C9pCQ8fimqAKEKyejXrx+3bt1i0qRJ2Nraiq/PmTOHHTt2YGVlJWaEHT16lF9++YXOnTvj7Oys0qrSKrnWokAZAUKZTMauXbu4fv26aB1w8+ZN0VO8MCg7c0ultXiIjo7m3LlzPHz4kKioKLKzs6lRowaGhob079+/RNocBAcHEx0dTVZWFjVq1KBRo0ZKtxP8UlRapSE9PZ3r16/j5OTEpUuXGD9+vMJN7qJEX1+fqKioXBuohakeBiTbaC0tWuvVq0dCQgJ+fn7o6urmOhYUFIShoSGCIPDixQuFzd9DQ0Np1aoV1apVIygoSKlaa9euTWZmJqGhoXkSKOrUqUNGRgYRERFiRdnHJCUlif1e3rx5o1StTZs2JSoqinv37n1RBeDz58/p2LEjWlpavHjxQgkKc6MoCJGRkcGOHTtYv349MTExVKxYkREjRvDTTz8VW885+d/51atXVK9ePdcxLS0t0tPTCQkJoXLlygrHv337loYNG1K1alWCg4OVqrV58+ZERETg7u6ep8ect7c3pqamCILA/fv3Fd73/fz86NKlC3p6evj5+SlVa5s2bQgKCsLBwaHQaypATCRs2LAh3t7eRS/wI5o0aUJMTAweHh60atUqz/HIyEjat29PYmIimzZtYuzYsbmOSxl0K01a5e/1NQiCoPR+idra2qSmpvLmzZsv2uyT3wsqVqxIWFiYEhS+R1dXV9yozC/pLzExET09PerUqSP2p5QTHh5O8+bN+eabb3j+/LnSdMK/18+goKA8PYXj4+OpV68egiAoPA7vq5AbNGiApqYmkZGRStVaGDw8PAC+6LomNSEhIQClwqJVpVWFCuWRlZVVoqpxVZQcVAFCFZIh3yR68uRJLgspeUauo6Oj2AslNjaWRo0aSbIhpNKq0qoslBEgVERpsgdSaVVREPIsrNKASqu0fGzlowxkMhnOzs7Mnz+fV69eiX1xCttDZP78+UpS+C+lRWutWrXIyspSuIGZnp5OnTp1CrzOpqSkoK2tjbq6OjExMUrV2qxZMyIjI3n+/DlaWlq5jjVq1Ii3b98WuGGcnJws9v9T5qYw/BvIioyMpFy5coUeL//spdpsLeh+mpyczJYtW9i6dSvx8fEIgkDdunUZMGAA3bt3p2vXrpLZYDVu3JjY2FiFAcL69esTHx9f4GeelpaGlpYW5cuXJyIiQqla5d+tD3sny0lISKBu3boIgkBMTIzCjaDU1FS++eYbNDQ0iI6OVqrW0jZf5Z9tVFRUvvfOjRs3snDhQrS0tPD29s41R6VcP5YmrQsXLuTEiRMF2nN9DvJEPmXRsGFD4uLiePbsGd98802hx0dFRaGvr0/16tV5/fp10Qv8/+jp6ZGUlFTgfUl+TSpXrpzY60mOPJApxTVAHsxUlAwUHR1NkyZNEARBrCr/GPm+gBT318JQtWpV1NTUlB60LgpUWpVDadKq4ssIDAwU+5O3bNkyV9LV8+fP2bp1Kz4+PiQlJaGjo4O5uTkTJkyQ1K1JngCiKGkwKiqKLVu24OzsTGBgIFlZWVSuXJlvv/2WH374gZEjRxZbwPDp06e4u7vj7+8vWoympKSIFqN6enro6+tjamqqMAlKahITEwkICCAkJISkpCRSU1NFrbq6uujr61OtWrXilvnFqMLGKiQjOTkZIFc/Ifniu1y5crmyheWZuUlJSdKK/P+otCqH0qS1NDF37tyvzsj9+++/sbS0VPhQVpSotCoH+cNJZGRkqQkEZWVlsWfPHi5evMizZ8+IiYlBJpMRFxeHv78/u3fvZsqUKTRs2LC4paq0FiFF3TumKKsKBUGgb9++NG3alPbt2yOTyZg8ebLSkzy+hNKitXbt2oSHh+Pn55enx1G5cuVyuQko4uXLl8D7hBtl07FjR+zt7Tlw4ABz5szJdaxTp044Ojpy48aNfHtKXLlyBUCS75auri6vXr3C09NT7JtbGO7evSv+nOKmYsWKzJ07FysrK44fP86BAwd4/PgxdnZ22NnZUbZsWZo1a0bbtm3ZunWrUrUYGhpy/fp1zpw5g6WlZa5jbdu2xc3NjXv37im0wIN/q0mUbYcM720WExISePPmTR7LzsqVK9O2bVuAfDd95MGC/Cpii5IaNWoQERHB69evadasWaHHyxMFPw7aKouqVasSGxtLZGRkvlUhU6dOZe/evbx+/ZpFixZ98lqmLEqT1qVLl7JgwQLmzJnDvn37EASBs2fPljhnizZt2uDq6sr69etZvXp1ocdv2LABQOlW7vr6+jx8+BBnZ+d8bY/l16QPE3PlXLt2Ld9jRU3z5s25f/8+9vb2ea6tFy5cEP///v37Cm287927B0CDBg2UqvNLKKx7Q3Gi0qocSpNWFZ/PmzdvmDJlCjdv3sz1+uDBg9m+fTve3t4MHTqU5ORkcQ68ePECNzc3tm3bxokTJyTrR9m+fXuFgWp3d3fGjh1LXFxcrnmakJCAm5sbN27cYOfOnRw+fFiStaucY8eOsWbNGvE5r6DvkHw/rtn/Y++8o6K6vr/9XJCmBGJDwV7AaASNWANiwwbEGo3lFxtWrJgomhh7VGKNBb921CjR2AlFJQoqsWFFRQUsgHRQmnTm/cN3Jk4oimHuQHKftbJWmHsP83G4c+85Z+/92c2aMX/+/EJtIFRNSkoKu3bt4uTJk9y9e/ed33cLCwsGDx6Mo6Oj2lv6lBYpQCghGjVq1CAuLo5nz55hZmYGvJmYymQy2rVrp7SpLbdmUpeHr6RV0nrw4EGA9+494eHhgaGhIXZ2dorXXFxcSl3N8SF89913//h3uLq60q9fP5UHsiStqqF+/fpERkYSHh5O8+bNVfpeZUF4eDiDBg3i+fPnSpMs+QQwPT2drVu3snfvXnbs2FFkbzKxkLSWLStXrixV4F3eO7O411VhO9qkSRMsLS0rRJ+b8q61Q4cOHD9+nAULFuDp6VkoGPGuHsM///wzgiBgaWmpSpnAm55sXl5erFq1iipVqjB58mQ0NDSANz3dfH19+eGHH2jfvn2he/qTJ0+YP38+giAUu1FblvTr148NGzYwdepUDh06RIsWLd577IMHD5g6dSqCINC/f38VqiwdBgYGTJgwgQkTJhAcHMzevXs5c+YMz58/5969e9y/f1/lAcLJkydz7tw5FixYQO3atbG3t1ccmzZtGv7+/ixcuBBvb+9C13JycrLiGvjiiy9UqhOgRYsWXLlyhV9++YXFixcrHRMEgYCAgBLHy+37P8SitrTY2Nhw6NAh5s6dy6+//lqo4rEksrOzmTNnDoIg0LVrV9WJfIs2bdpw9uxZtm/fzrJly4o8R0tLi3Xr1jFw4EB27NhB165dla4XsahIWgG0tbX56aefOH78OKmpqRgbG1O/fn21aCmO6dOn4+/vz7Zt24iLi2PWrFmKgHtJ3L59mw0bNnDixAk0NDSYOXOmSnUOHTqUmzdv4uLiQrNmzQptRD9//lyR7Pj2+hTe9PSbPXs2giCIstk6fPhwgoKCWLhwIZqamop75O+//86iRYvQ1NQkPz+fJUuWYGNjo3R/zczMZPHixQiCQJ8+fVSuVUJCQuLVq1f07duXiIgIZDIZRkZG6Ovr8+zZM06cOEH16tW5cuUK6enpWFpaMnToUGrWrEloaCh79uzhxYsXDBkyhMDAQFGSHKFwkC0iIoLhw4eTlpZGrVq1cHJywsrKiurVq5OamsqVK1dwc3Pj9u3bDBw4kAsXLpRqfvahTJ8+nf379yOTydDV1aVt27aYm5srrLm1tbXJysoiPT2d6Oho7t+/T1BQEA8fPmTMmDGF2lWpkvPnz+Po6EhycrLi8zU0NFQ4xrytNSYmhrS0NO7cucPdu3fZsmUL7u7uCoe8ioBkMSohGqNGjeLUqVMMGjSI3bt3k52dTa9evbhz5w7Lly9n2rRpinPnz5+Pm5sb7du3V2RkS1olrWJSWruI+vXro6GhoVIrGVUilh1qWSBpLcz27duZM2cOEydOVFtm+PuSkpKClZUVkZGRNGnShDlz5mBpaUm7du0UNlepqak4Oztz5MgRdHV1CQwMLFQhIWmtmFr37dtHZGQka9euJT8/n0qVKtG8eXPq1q2LlpYWERERhISEkJ2djYaGBv379y9xsbJ161aV6Jw7dy7bt2/nypUr5f5eU5613rx5k549e5Kfn4+JiQkODg40aNCAqVOnFjsmOjqa8PBw9u7dy2+//YYgCBw7dozu3burXO/27dtxcXFBJpNRt25d7O3tadOmDQ0aNMDLy4uNGzdiZGTEuHHjaNmyJTk5OVy9epWDBw+SlpaGhYUFf/zxh8orudPS0rCxseHJkydUqlSJnj17Ymtri7m5OSYmJujr66OtrU12drZigR0cHIyfnx9+fn7k5eVhampKQECAKIlY/8TG8MmTJ5w7dw5/f39++eWXshf3NxYtWsSGDRsQBIH27dvTv39/LC0tqV+/vqJnYosWLZg2bZrSNeDm5saLFy+oV68ef/75JwYGBirVuXv3bpydndHU1MTJyYkhQ4bQoEGD97I2On/+PKNGjSItLY0lS5aoPJARGhpK165dycjIoF69ekyaNImePXuWWE348OFD/Pz82L59O8+fP8fAwICAgAAaN26sUq3wppf0iBEjEASBUaNGMXr0aJo3b16k1e23337Ljh070NXVZeXKlYwePZpq1aqJZttZkbS+zYgRI/D29i6Xzy2ALVu28MMPP1BQUABA9erVadmypaLP7N/vr/fu3SMpKQmZTIampiYrVqxg8uTJKtWYm5tL3759uX79Otra2jg4OPDZZ5+RnZ3No0ePOHXqFNnZ2dSuXZvAwECFg8+gQYMUCbrNmzfn7NmzxfZVLSsKCgoYPHgw586dKzLpy9XVlVu3buHh4UHz5s0ZO3YsdevWJSIigl27dhEaGkqNGjW4evWqkhORuqlI7SgkraqhPGh9/fp1mfwesezcKwLLly9n9erVGBsbs3v3bkWQJzo6mq+++org4GAAunfvzpEjRxQJhfBmTd67d28ePnzI3LlzyyTp/F0UdR3OnDkTd3d3zMzM8PX1LTJhPS0tjb59+3Lv3j0WLlzI7NmzVarzwIEDODk5oampydy5c5kyZcp7tRBJTU1l27ZtrFq1ivz8fHbs2MGQIUNUqvXBgwd0796dzMxMTE1NcXJywtbWtsSkpoiICPz8/Ni2bRsPHz5EX18ff39/UZLxygIpQCghGlevXqV3797Am14UBQUFJCQkoK+vz927d6levToXL15kyZIlikz4FStW4OTkJGmVtKpcW2RkJBEREYqf7ezsEAQBb2/vd5aRR0RE4OTkhI6Ojsp7zqgKKeimGsTUunLlSlavXs348eOZMGFCuZ2IuLq6smLFClq1aoWXl5diU6Koie3kyZPx8PBg7NixCssmSWvF1pqcnIy1tTXR0dGMHTuWb775ppClSXx8PGvWrGHbtm1YWlri6+srunXunTt3CAwMZPjw4aLZ2n0o5V3rkSNHmDlzpsIy/F0bKfJeRfJn77fffssPP/wghlTgjR3PDz/8wK1btwCK3Mx8G3k16+DBg1m/fr3KA0NykpKSmDp1Kj4+PsC7dcJf2cUODg5s3LhR5dXtcsrDBlpp8PDwYOnSpURHR793xbNMJqN9+/bs2bNHFJumgoICRowYgY+Pj0KjIAglJrYNGTKEkJAQoqKikMlktGzZEj8/P1Eyxi9fvsyYMWOIjY1V6NXS0sLY2Bh9fX20tLTIyckhPT2d2NhYcnNzgTefq7GxMXv37i1kU6xK5MG0tz/bXbt2MWjQIKXz8vLyGDFiBKdPn0YQBD766CNSU1NFvd4rklY58s3Xq1evltv5/K1bt1i9ejVnz54lJydH6ZggCIXWhzo6OvTq1Ytvv/32vSoOy4JXr14xadIkRUWw/BqQa2vSpAkHDhxQchexsrIiNDSUkSNH8uOPP4oWFMjNzWXFihXs3r1bcb1Vr16d7777jvHjx5OSksKgQYMICgpSuu/KZDKqVavGoUOHaN++vSha35eK9GyTtKqG8qBVruGf8K75Q1nRqFGjMtEaHh5eRoqKplOnToSEhODu7l6oytrHx4dhw4YhCAKnT58ucm5y5swZhgwZgrm5eSGLUlVQ1HXYsmVLoqKiOHz4cJHWzXLOnTvHwIEDsbCw4OLFiyrVaWtrS1BQUKHikPdl8+bNfP/993To0IEzZ86oQOFfjBs3jqNHj9KzZ08OHjxYqr2IvLw8hg8fzpkzZxg6dCg7duxQodKyQwoQSoiKu7s7Li4uZGVlAW/sIzdv3qxYwGzatIkFCxYAb+xojh8/rraGqZLW/5bWlStXflCfCTlym1Q/P78yVCUeUtBNNYil9auvvgLg7t27xMTEAG++Wx9//DGamprFjrt7965KdRWFlZUV9+/fx8vLCysrK8XrRU1sQ0JC6NixIw0aNJC0/ku0zps3j61btzJjxoxi7dDkLF68mA0bNjBv3jyVWIlKiEdSUhJHjx7lxo0bxMfHc/z48WLPNTY2BqBz585MmTKFbt26iSVTiVu3bnH69Glu375NWFgYCQkJvH79mvz8fKpUqUK1atUwNTWlU6dO9OvXT21JGcHBwRw/fpxLly4RGhpKcnJyoXOqVauGmZkZ1tbWDBw4ULSeKHLKwwZaacnJycHHx0dxDYSHhyvmrnK0tbVp1KgRnTp1on///qJUub6NTCZj9+7d7Nu3j3v37pGXl0dKSkqx55uYmJCRkYGmpiaDBg1i9erVoiYVvH79Gnd3d06cOEFQUBD5+fnFnlupUiXatm3LwIEDGT16tChBzL9z4sQJNm/ezM2bN8nPz2fPnj2Fgm4A+fn5uLq6smXLlvdOhPgva4U3waLXr19jYGDwjzeLVc3r16+5evUqoaGhREVFkZ6eTk5ODtra2ujr61O3bl3MzMxo37692ipwrly5wu+//05oaCg5OTkYGxvTtWtXBg4ciJaWltK5165do2XLlmrTWlBQQGRkJBoaGpiYmCitU7Kysti5cyc+Pj7ExsZSo0YNunTpwqRJk0RLaCkN8oRiLy8vdUt5Jy1btkRDQ0Mta5TSImktHQsXLuTw4cOKPYAPpaT5Q1kxZswYfHx8Cs2nSoMYzyxjY2MyMzN5+vRpoXlSXFwcZmZmCIJAREREkYmBSUlJNG7cmCpVqhAdHa1SrVD0PLtmzZrk5uYSHR1d4v0+MzOT2rVri6K1Xr16pKWl8ezZs/dyvPg7L1++pGHDhhgYGBAZGVn2At/CzMyM+Ph4rl+//kFrvEePHtG+fXtq1arF48ePVaCw7JEChBKik5iYyOXLl9HS0sLS0lKpR5uPjw++vr7Y2NgwcOBApVJtdSBpVQ3lUaubm5uSVV1ERASCIFCvXr13jhUEgYYNG7Jq1apS9QEqT0hBN9Ugltb3sWb4O+rarDUxMeH169ckJCQobVoUNbHNzs7GyMgIbW1tEhISJK3/Aq0WFhZERETw4MEDTExMSjw3JiaGTz75BFNTU5X32Cuu12F55N+uNSYmhlq1aql9rlJRyczMJCMjg+zsbHR0dKhSpYpagitvI3doKG+9xkpLWlqaIkhcuXJlDAwMys11mpubS3JyMrVq1Sr2nA0bNlCvXj1sbGxE6ZFdEllZWTx9+pTIyMhC12u9evVo3LgxOjo6atUoJz09nefPn1O7du0SgxSZmZn4+/tz584dXrx4waZNm0RU+YaKpFVCQkJComzIyclhzpw5uLu7IwgCx48fp0mTJqX6HWLN0ZKSknBycsLX1xdBENiyZQsNGjQo1e+wtrZWkbo31KpVi+zsbMLCwgrZGufl5VG9evUS91LkgSxdXV3i4uJUqhWKXu+bmpqSkJDAixcvSmwnIA9m6unpqdwNrX79+qSmphYZeH0fXr16RYMGDTA0NFRyf1MFRkZG5OTkEBcX90HzUfl+i1jXQFkgBQglJCQkiqAiZrv/E6Sgm2oQS+uHWleoenJdFA0aNCAlJaXQhLuo71xERATm5uaiTAIlreIgz2aMj49/p1VHTk4ONWvWFGVi3bBhQ/r06YOdnR09evQQpS/bh1LRtPbu3Rt7e/tyr1VCQkJCQuJ9kAe01c3BgwfR09NjwIAB5T5xqCJplSgf3Lt3D0B01wN4035GR0cHIyMj0d/7Q8nOzsbU1JTU1NRy299VTmpqKmZmZmRlZZVLrW3atOHJkyfs27ePfv36FToeEhICoGTf/DYBAQH069ePhg0bcufOHZVqhaLX+xMnTuTw4cP88ssvODg4FDv26NGjjBs3jubNm3PlyhWV6uzduzdXr17lhx9+4Jtvvin1+A0bNrBo0SI+//xzRYsFVfHZZ5/x9OlTTp06hY2NTanHX7x4EQcHB5o0acLNmzdVoLDsUY/HoISEhEQ5Z/jw4dLiRaLCoI5A34ci9+I/dOgQU6dOLfFcuWWvuhYNktayp2rVqsTHx3Pr1q139pOS94ATI6g0d+5cfH19GTduHBoaGlhZWWFvb0/fvn2pU6eOyt+/NEha1ceZM2fw9fVV2E1Wq1aNzz77jMGDB5c6U7usCQkJITQ0lIiICDIyMsjMzFRY4NWpUwczMzPMzc3Vos3CwgI9PT1Wrlwpug3nf4W4uDguX75MRkYGDRo0oF27du8MYHh7ewNvbPLUQXJysqKC8PXr14oKwrp161aITdmcnByCgoIUVojt2rVTa7VuXl4ed+/eVVwD71MNos4N+Hcxf/58BEFgxYoVatPw4sULvLy8FBbO8utV3uNPT09PcX+1sbGhX79+73RHKEumTJmCIAjs3LmTXbt2Ubt2bdHeu7S8rXX37t0lVjuXF548ecKDBw+QyWS0aNFC6Tn/6NEjtmzZQnBwMOnp6ZiYmGBra8vYsWPR19dXi96QkBAuXryodK3+/d5qampKly5d+PTTT9WisTRYWVmhoaEhSm+8vyO3Dp09ezYLFiyoEPtCOjo6WFtbK57t5RkDAwOsrKz4448/1C2lSGxtbdm2bRtz586ladOmhVzCigsMwpu5wcKFCxEE4YMCS/+E/v3788knn9CiRQtsbGz47bffmDt3Lq1atSrSGe3evXt8//33CIJAnz59VK5vwoQJXLlyheXLl5OSksL06dPfy9EiISGBzZs3s2nTJgRBYNKkSSrX2q9fPzZs2MDUqVM5dOhQqZziHjx4wNSpUxEEgf79+6tQZdkiVRBKqIS2bdsSFham1Oy2pKyF4hAEAU9Pz7KWp4SkVTVUJK0SUlWeqlCFVjc3N1JTU5V6sq1atQpBEHBxcSmz91EVhw8fZsKECejq6rJu3TpGjhwJFM58Cw8Px9bWlpcvX7Ju3TrGjRsnaf0XaB0/fjy//fYbbdu2xdPTs9ieCJmZmTg4OHDjxg369u2Lh4eHKPpSU1M5c+YMPj4+nD17ltTUVMzNzRUVe5999pkoOt4HSWvZY2pqioaGBo8ePVJ6PSYmhtGjR3Pt2jUAxeYwvJmnaGhoMG7cOFasWFGqJvb/lCdPnrBx40Y8PT1JSkp65/nVqlVjwIABzJo1S1S7T/l9SBAEnJ2dmT9/fqG+WBIfRnZ2NnPmzOGXX36hoKBA8XrNmjX5/vvvGTNmTLFjDQ0NRd18LSgo4NixY5w6dYqLFy+W+L4GBgbY2NgwePBgtVQcRUVF4e7uzr179xAEAQsLC8aPH6/YyDp+/Dhz585VsumuXLkyzs7OzJkzR1StAGvWrOHnn38mLS1N8Zq5uTmLFi3C1ta22HFiXwOlQZ1uLhkZGbi4uPDrr7+Sl5endM8vDkEQ0NLSYtSoUfz444/o6uqqXKf8M4I3CViurq4MHTpU5e/7IVQkrS9evGDSpEmFHFoGDBjAtm3buH37NoMGDVIKFsOba8DExITDhw+LGnT/9ddfWbNmDWFhYQAlXq/yv0GzZs2YP38+AwYMEEPiB6HOe4C8fYcgCHTs2BE3NzcaN24suo7Ssnz5clavXs3Vq1fL/V7J4sWLWb9+fbnUGhMTg7W1NYmJiQiCQIsWLWjYsCEHDx4sdsyRI0d4/Pgxhw8f5unTp+jp6XHhwgXMzMxUrvfv7Wb+Pmdq06YN586dU/wcFRXFwoUL8fLyIisri9q1a3P58mWqVaumcq3z5s1j69atCIKApqYmFhYWmJubY2Jigr6+Ptra2uTk5JCWlkZ0dDTBwcEEBweTn5+PTCZj+vTpLF++XOU609LSsLGx4cmTJ1SqVImePXtia2tbSGt2djbp6ekKrX5+fvj5+ZGXl4epqSkBAQEVxkFHChBKqIS2bdsSGhqq9EAvrz2yJK2qoSJpLYm4uDiCgoLo2bOnYtMvLS2NxYsXExAQQEFBAb1792b+/PlFNiiuKPzXg26qQhVaa9euTVZWFjExMYpM9YpmiTtq1ChOnjypmHB37NiRXbt2IQgCy5cvJzg4mJMnT5KZmYm1tTWenp5q6/MkaS1bHj9+jJWVFbm5uZiamuLi4oKtra2iUXlKSgp+fn64urry6NEjBEHAx8eHTp06iaoTID8/n0uXLuHr64uPjw9Pnz7F2NiYvn370rdvX7p27SpqMKgkJK1lQ1H30vT0dLp160ZoaCgAPXr0wNramurVqytsnHx8fMjPz8fe3p4DBw6IovXgwYM4OzuTnZ2NTCZDR0cHMzMzTExMqFKlimLRmpaWRkxMDKGhoeTk5CAIAnp6emzZsoVBgwaJolX+udrY2BAQEEDz5s3ZtGkT7dq1E+X9/60UFBQwcOBAAgICkMlk1K9fn5o1axIWFkZKSooiILto0aIix4s5d7h//z6jR48mLCxMafO6SpUqius1KytLUf0qR/4827t3L6ampirXCXDixAkmT55MVlaWQqsgCBgbG+Pp6UlISAijRo2ioKCAatWqYWJiwosXL3j58iWCIPD111+L2tNv0qRJHDp0SHEfMDAwUAQuNTU1Wb16NY6OjkWOLc/zR3Vpy8rKolevXty9exeZTEbbtm2xtbXFwsJCsSmopaWldH+9d+8ef/zxB9evX0cQBCwtLfHx8VH5s0z+Gf3+++84OTkRERFBjx49WLVqlWjfl/elomh99eoVNjY2REREIJPJMDIyQl9fn2fPniGTyXB0dOTKlSvcu3cPS0tLhg4dSs2aNQkNDWXPnj3ExsZiYmJCYGCgKJvt06dPZ//+/chkMnR1dWnbti3m5ubUqVNH6d4q38C+f/8+QUFBZGVlIQgCEyZMYPXq1SrXCfDDDz+U6vyNGzciCALTp09XvCYIAkuXLi1raYWQX6/z5s1jzZo1VKpUiXnz5jF16tRyneCUm5vL69evMTAwKPdVj0lJSURHR9OsWbNys0Z5m4cPH+Lk5MSNGzeAd+9LmpiY8Pr1a2QyGQYGBmzfvp2+ffuKojUrK4vw8HDCwsIK/ZecnEyLFi24fPmy4nw/Pz8GDx4MvKmWdXd3F/U+7OnpiaurK8HBwYrXirpe354vtmrVinnz5onqepGUlMTUqVMVdqbv852Sa3ZwcGDjxo0l9oMub0gBQgmVsGTJEkWD061btwJ88IaJvApCVUhaVUNF0locy5cvZ/369RQUFPD48WNF1vAXX3zBxYsXlTYNWrdujZ+fH5UqVUzn5v960E1VqEKrubk5kZGRDBs2TGFbIbft2bp163tlOcsZMWJEmekqDXl5eSxbtgw3NzfFhvXb3yeZTIYgCAwbNow1a9aozapH0qoafH19cXR0JD09XTHR1tfXRxAERfWDTCZDU1OTlStXimIj8j6EhITg7e2Nr68vQUFB6Onp0a1bN+zs7Ojdu3ehJvbqRNL6YRS1Ib1q1SpWrlyJoaEhHh4eWFlZFRp3584dBg4cSHJyMjt27GDIkCEq1XnlyhXs7OzIz8+nc+fOzJo1CxsbmxI3WHJycrhw4QKbNm3C398fLS0tfH19adu2rUq1gvLnun37dhYvXszr168ZMmQIixYtom7duirX8G9k7969zJgxAx0dHbZu3arY7MnMzMTV1ZX169cjCAIHDhzA3t6+0HixAjCRkZF07tyZly9fUq1aNUaPHq3Iwi4qefDly5fcv38fPz8/9u/fT2JiIjVr1uTSpUsqt1C8f/8+Xbt2JScnh5YtW9KnTx80NTXx9fXlzp07fPLJJyQnJ/Py5Us2bNjAyJEjFc/XvXv38s0335Cfn8+RI0dKrNwrK06ePMmoUaPQ0NBg4cKFODk5oaOjQ0xMDAsWLODIkSNoamri7e1Nx44dC40XMwhX2uqbpKQkBEFQCrIIgkB4eHhZS1Ni5cqVrFq1iho1arB3795S2fhfvnyZUaNGkZCQwPfff6/yatK3/34ZGRksWLCAPXv2UKlSJb7++mucnZ1FrRYviYqiVV6BZWxszO7du/n8888BiI6O5quvvlJsaHfv3p0jR44oJdqlpKTQu3dvHj58yNy5c/nuu+9UqvXAgQM4OTmhqanJ3LlzmTJlynslZKemprJt2zZWrVpFfn6+KPMWUK4iBRTrkuJ4ew3z9vli3K/evl7v3r3LlClTuHfvHo0aNWLhwoWiJVhJqJ+QkBBu3LhBfHw8s2fPLva8Tp06YWxsTLdu3Rg5cqQoCQLvw6tXr4iNjVXaj7p27Ro7d+5kwIAB9OnTR23JzeHh4QoL76ioKNLT08nJyVG0SKhbty5mZmZYW1urtYI3ODiY48ePK7QmJycXOqdatWoKrQMHDiyX1u3vQgoQSkhISBSBvFkvgJGREdeuXaNq1apcunQJe3t7RS8dLS0tFixYwKtXr/jpp5+YOHGimpV/GP/1oJuqUIVW+cZFWWQFqjtjPCEhgRMnTnDr1i3i4+PJz8+nWrVqWFhYKJo6lxckrWVLVFQUa9eu5eTJk4WsEfX09LC1tWX27Nm0adNGTQpLJjExER8fH3x8fPD39ycrKwtLS0vs7e358ssvy1XAQ9L6/hS1Wd6xY0cePnzI+vXrGTt2bLFj5Rt1Xbp04dSpUyrV+dVXX+Hr68uIESMUSVilYcqUKRw8eBB7e/sS7ZLKir9/rk+fPmXq1KkEBgaira3NiBEjmDFjRrm4N5W2wqEoxKpw6NOnD1euXGH+/PlFWox///33bN68GSMjI27evMlHH32kdFys4NCMGTPYu3cvlpaW/Pbbb6XKpn716hWDBg3i5s2bjB07lvXr16tQ6V822Pb29uzfvx9NTU3gTbXm//3f/+Hl5aWoaFm2bFmh8fPnz8fNzU2071b//v0JCAgotgrI0dGRI0eO0KhRI65du1YoiUDMAGH9+vVJSUn5R79DDK3t2rUjNDQUDw+PD6r+8PHxYdiwYTRr1kxhS60qivr7BQQE8P333xMcHIyWlhaDBg3C0dHxnX2fVU1F0dqpUydCQkJwd3cvZL8p/9sKgsDp06eL1HnmzBmGDBmi6A2uSmxtbQkKCmL58uVMmzat1OM3b97M999/T4cOHThz5owKFCqzc+dOFi5cSEZGBoIgYGdnV2JA8+DBgwiCwPDhw5Ve/5B5T2n5+/Wal5eHq6srmzZtIisri6ZNmzJz5ky+/PJLtfaelZCQEJ/MzEwyMjLIzs5W9Hj9N9wHpAChhEooywWRqitcJK2qoSJpLQo7Ozv+/PPPQgvuOXPmsH37dqZMmcKqVasA8PDwYPLkyXTq1AlfX1/RtZYF//Wgm6pQhVaZTMbOnTs5f/68YqPl0qVLCIJQZGVLSXh5eZWZLgmJDyUiIoKEhATy8vKoVq0ajRs3VmzKVgSys7M5f/48Pj4+nD59mjFjxij1CC1PSFpLpqgNTLmtc3h4eImBjeTkZBo1asTHH3/M8+fPVaqzSZMmJCUlERwcTL169Uo9PiIiAnNzc2rUqKHyahwoPgjh6enJ8uXLefjwIRoaGnTp0oXRo0fTp08ftS20a9asSW5u7gePF7PCoX79+qSmpnL79m0aNmxY6HhOTg7t2rXj+fPnzJo1i8WLFysdFys41KJFC6Kjo/H396d169alHn/r1i26du1K3bp1uX//ftkLfItmzZoRFxdHYGAgn376qdKxBw8e0KlTJwRB4Pr160XacT169Ij27dtjZGSksCVWJQ0bNuTVq1fF6klLS6NNmzYkJCSwZMkSZs6cqXRczABhbGwskydP5vz58wiCwLhx44qtwpHJZDg4OCgsKd+mNBV9H0KtWrXIzs5WsvIvDZmZmdSuXRs9PT2Fm46qKOnvd/ToUVasWEFYWBiCIGBqasqgQYPo169foWtbDCqKVmNjYzIzM3n69ClVq1ZVOhYXF4eZmRmCIBAREVFke5GkpCQaN25MlSpViI6OVqnWevXqkZaWxrNnzxRW/aXh5cuXNGzYEAMDAyIjI8teYBGEhYUxadIkgoKCMDExYfPmzfTo0aPIc9Xdg7Co946NjcXV1ZX9+/eTl5eHgYEBX375JQMHDsTa2rpc23rK/8YfMm+UkJD49yMFCCVUwt/tAz4EsRbYklbVUJG0FoV80+XBgweYmJgoXpdXEnh7eyssR+QLATE2BVXFfz3opirE0lqee8j8HUNDQzQ0NIiLiyuX/QbeRtIqLnJLkYpOSkrKB/XcVQeSVmWKupfKN+Di4+NLvD5fv36NsbEx2traiv5fqqKoXrSlQb6BXblyZWJiYlSgUJmSnlEymYxff/2VVatW8ezZM0WPxB49etCtWzdsbGxE7YuSmpqKh4cHq1atIjk5+b2qHIpCjAoHeTAzISGh2J5Iv//+OyNHjkRXV5egoCCljUGx5g5GRkbk5OQQFxeHjo5OqcdnZ2djZGSErq4ucXFxKlD4FzVq1CAvL4/Y2Fh0dXWVjsm/N4IgFHkc3vQBqlWrFlpaWiQmJqpU69t6S7oG9u3bx/Tp0zE0NOTWrVtKiQ7qmD9u376dRYsWkZmZyZdffsnatWuL/H6pa27btGlTEhMTiw28vwt5Aoa8H6gqeddnVFBQgIeHBzt27ODWrVuKtXnNmjXp3LkzlpaWtG7dutQJhv9mrfIAcVhYWCGL87y8PKpXr17iv0MedBPjfiXfrygqmPk+vHr1igYNGmBoaEhERIQKFBZNQUEBq1evZvXq1eTl5eHo6Mjy5csLzWfKY4BQzrNnz3B1deXYsWOKfo7VqlXDxsaGLl26YGlpSYsWLcpV+xn5WvHly5fqlvJOJK2qoSJpLY+EhIQQGhpKRESEome23A61Tp06mJmZYW5urm6ZH0z5uVtJ/KuwsrIqMjiUm5vL1atXFT8bGhpSr149NDU1ef78ueIBbGBgwLhx40R5oEpaJa1FkZGRAaC0MHj58iUPHz5ER0dHqWeP3LIpPT1dXJESEv8fFxeXfxyQ/+mnn3B0dFR5I+X69esTGRlJeHg4zZs3V+l7/VMkraojLy+P3bt38/vvv/Pw4UMSExORyWS8fPmS0NBQdu3axaRJk2jUqJHaNMqrxMsKVVa/SVpVh6WlJf7+/gQHB2NpaVnseXfu3AHebC6qmoYNG/Lw4UP8/Pz44osvSj3+3Llzit+jbuT2YcOGDePMmTPs27eP06dP4+npqagcMjAwoFWrVnh6eqpcj4GBAZMmTaJdu3Z069YNgIULF5bLpKRatWoRFRXFo0ePiu114uDgQJcuXQgICGDq1Kkqt78tilq1ahEZGcm9e/dK/A4Vx4MHD4A3gUZVU7VqVRISEnj+/DnNmjVTOvb2Bnp0dHSR/XDkAfe/27mqiho1ahAbG8vz589p2rRpked8/fXX7Ny5k7t37/Ltt9+yZ88eUbQVx8SJE+nWrRsTJ07kt99+488//2Tz5s10795drbrkdOjQAS8vL5YuXcru3btLPX7p0qUIgkCnTp1UoK50aGhoMHLkSEaOHMmDBw9wd3fn8OHDxMfHc/ToUY4dO4YgCOVis7i8aK1Tpw5Pnjzhzz//pF+/fkrHKlWqxJUrV0ocf/fuXQCV90sFaN68OVevXmX37t188803pR7v7u4OIHqVpoaGBi4uLvTq1YuJEycqnHG2bdtGu3btRNXyoTRs2JCtW7eycuVKPDw82L9/P/fv3+f48eOcOHECAG1tbeLj49Ur9G/I+zpWBCStqqEiaS0PPHnyhI0bN+Lp6VmoLUpRVKtWjQEDBjBr1qxy0Ve3NEgVhBKikZeXx6BBgwgICKBbt27MmzevULP0O3fusGLFCnx9fenatSvHjh1Ti82YpFXSKrcYunbtGmZmZsBffQk7d+6sZHfz9OlTWrduLXr2nRy5nev7WrF6eHhgaGiInZ2d4jVXV1fGjx+v8uCQpLX8Ur16dQIDA1W+Cbp9+3bmzJnDxIkTi+yXU56QtKqG8PBwBg0axPPnz5UWKfJMXbmdXOXKldmxYwcODg5q0VnaSnh51Xtxr6syA1rSWrbaFixYwCeffELz5s0JDw9nyJAhfP7555w6darIKp2MjAz69evHjRs3GD58uMqrx9auXcvSpUv5+OOP2bFjB7169XrvsWfPnmXChAm8evWKRYsW4ezsrEKlbyhtFUBiYiIeHh74+vpy7do1cnJy1FJFYG1tzb1797hy5Uq5DBBOnDiRQ4cO0bNnTw4dOlTsfDksLAxra2uysrJwdnZm0aJFgHjVGbNnz2bXrl1YWFhw9OjRUgX6EhISGDx4MHfv3mX8+PGsWbNGhUph1KhRnDp1ikGDBhUKDo0bN46jR48iCAKLFy9m1qxZhcavW7eOJUuW0LVrV06ePKlSrfAm+Ofp6cmwYcP43//+V+x5N2/exNbWVlG5M2HCBEC9FTr5+fn89NNPrFmzhvz8/EJVROrSduPGDXr37k1eXh5t27Zl5syZdOvWDX19/WLHpKenc+7cOTZu3EhQUBBaWlqcPXv2gyx1S8OHfEbyZN3z589z7tw57ty5Q3JysupE/n8qita5c+eybds2jI2NOXbsGC1atHjvsTk5OfTs2ZM7d+7w9ddfs2nTJhUqhSNHjuDo6IiGhgbTp09n+vTp1KxZ853jEhIS2Lx5M5s2baKgoKDIfotikZ2dzQ8//MD27dvR0NBg1qxZfPfdd1SqVKlcVxAWxe3btxU9tIOCgsjPzy9X7j4VzXFI0lr2VCSt5YGDBw/i7OxMdnY2MpkMHR0dzMzMMDExoUqVKmhra5OdnU1aWhoxMTGEhoYq1ix6enps2bKlWCv18ogUIJQQjbVr17Js2TKGDBnCjh07Sjx3ypQpeHh4sHDhQmbPni2Swr+QtKqGiqT17xsE2dnZ9OrVizt37hRqBD5//nzc3Nxo3749Z8+eFV1raa0C6tevj4aGBs+ePVOtsCKQtJZfxLRuXblyJatXr2b8+PFMmDBBVPu40iJpLVtSUlKwsrIiMjKSJk2aMGfOHCwtLWnXrp1iwZKamoqzszNHjhxBV1eXwMDAYisjVMm+ffuIjIxk7dq15OfnU6lSJZo3b07dunXR0tIiIiKCkJAQsrOz0dDQoH///iXaPaoyaCRpLRvkNndvByR1dXXJycmhoKCAL774gv379yuOZWRkcPjwYTZt2kR4eDg6OjoEBASovIo3NzeXvn37cv36dQRBoHnz5vTs2ZOWLVtSp04d9PX1FYvW9PR0Xrx4wb179/Dz8yMkJASZTEanTp34/fffRXFq+CcbEpmZmVy8eBF/f39WrFhR9uJKwNnZmT179pTbAOG9e/fo2rUreXl5mJmZMXLkSD755BPatm1bKDHpl19+YerUqQiCwMCBA5k6dSo9evQQZaMoLi6Ozz//nKSkJD766COGDx+Ora0t5ubmCstOOQUFBcTGxhIcHIyfnx+HDh0iJSWFWrVqERgY+F6b3/+EGzdu0LNnTwoKCujQoQP29vYIgoCXlxdXrlyhQYMGvHr1iry8PA4dOqTUD8/f35/hw4eTmZnJ9u3bGTp0qEq1AgQGBmJnZ4cgCHTt2pXRo0fTvHlzGjRoUOi+uXr1apYvX46GhgYzZ87EyckJU1NTtW8W3rhxg4kTJxIWFkaTJk0UVUTq3Mg8fvw4U6dOJSMjA0EQ0NDQoEGDBsXeXyMiIigoKEAmk6Gvr8/WrVsLVZ+pgrL4jMSyGq8oWmNiYrC2tiYxMRFBEGjRogUNGzZUJI4WxZEjR3j8+DGHDx/m6dOn6OnpceHCBUWSsSqZN28eW7duRRAENDU1sbCwwNzcHBMTE8W1mpOTQ1paGtHR0QQHBxMcHEx+fj4ymYzp06ezfPlylet8F/7+/kyZMoWYmBjMzc3Ztm2boudrRQkQvk16ejoXL16kb9++ZSvsH1CRgkOSVtVQkbSqmytXrmBnZ0d+fj6dO3dm1qxZ2NjYlNhuIicnhwsXLrBp0yb8/f3R0tLC19dXyX2uPCMFCCVEo0OHDjx69IgbN27QpEmTEs+VV2SZmZlx/fp1kRT+haRVNVQkrVevXqV3797AG0ujgoICEhIS0NfX5+7du1SvXp2LFy+yZMkSgoKCAFixYgVOTk4q1xYZGalUqSjfGPD29n6nZUBERAROTk7o6OgQGxuraqmS1gqEWAHCr776CnhjwSO34qpSpQoff/xxidXCcsseMZG0lj2urq6sWLGCVq1a4eXlpbBhK2rBMnnyZDw8PBg7diwbNmwQVSdAcnIy1tbWREdHM3bsWL755hvq1q2rdE58fDxr1qxh27ZtWFpa4uvrq5Y+ipLWssHPz4+wsDDFf+Hh4URFRVFQUABAixYtuHz5stL5gwcPBqBy5cps3bpVtCz8rKwsFi5ciLu7O9nZ2e9VlSmTydDV1WXcuHEsXrz4g/rBfQgVdUPiwoULeHt7880336g8MPWhHDlyhOnTp/P69WvFNbB79+4iM5bXr1/PkiVLFD+L2es7NDSUsWPHEhwcrHStamhoULlyZbS0tMjJySEzM1PxfZNrbNWqFXv27Hnn2qGs2LdvH87OzuTl5Sm0ymQyqlevjpeXFzdu3FAEW1u1akWdOnWIjIwkODgYmUxG9+7dOX78uChaATZu3MiiRYsoKCh45zXg7OzM7t27lf5d5eG7mZWVxYIFC9i5c6eiimjt2rVq1fbixQs2bdrEyZMniY6Ofuf5derUYcCAAUyfPh1jY2MRFFase2tF0vrw4UOcnJy4ceMGwDt1m5iY8Pr1a2QyGQYGBmzfvl3UwJCnpyeurq4EBwcrXivOeUFOq1atmDdvnpLzjbpJSUlh9uzZHDlyBB0dHcXcpiIGCMsjFenfJGlVDeVBa6NGjf5xaxxBEAgPDy8jRUXz1Vdf4evry4gRIz4oGXXKlCkcPHgQe3v7EhNMyhNSgFBCNOQNn0tqoi4nNzeXGjVqiNLcuSgkraqhImmFN778Li4uZGVlAW822zdv3qxYcG/atIkFCxYAYGNjw/Hjx0XJxF+5ciWurq4fPF4mk9GuXTv8/PzKUFXRSForDmIFCD8k81edi8PSImktGSsrK+7fv4+XlxdWVlaK14tasISEhNCxY0caNGiglqCrPCt7xowZLFu2rMRzFy9ezIYNG5g3b57Ke+IVhaRVdeTk5BAeHk5YWBipqamMHDlScczPz4+ZM2fSr18/pk6dWijQKQYJCQl4e3tz8eJFQkNDiYqKIiMjg+zsbHR0dKhSpQp169bFzMyMzp07Y2dnp9RfWQzKw4bEv5nIyEj27NnD+fPnefLkCT///HOxgeoLFy7w008/ERgYqAgoifl38fb25tixY1y6dEmRzFIUJiYmWFtbM2jQILVUYDx69Ijdu3cTHByMhoYG5ubmODk5Ua9ePQC2bNnCkiVLyM7OVowRBIFhw4axfv36EqueVUFQUBBubm4EBASQmJjInj17irW1OnDgAK6urjx//hxQ37ylKM6dO4eTkxOxsbHlJngJb6zR33V/LaonpapZsWIFgiAwf/580d+7tFQkrXJCQkK4ceMG8fHxJToaderUCWNjY7p168bIkSOpVq2aiCr/Ijw8nEuXLimu1fT0dHJyctDW1kZfX19xrVpbW6vlen1fjh8/zqxZs3j16pXa7gHyRGEvLy/R31tVtGzZEg0NDbWsqUpLRZo3SlpLx5gxY/Dx8VHssX4IYvwbmjRpQlJSEsHBwYq5X2mIiIjA3NycGjVqqDyYWVZIAUIJ0WjYsCGvXr0iMDDwnY2Qg4ODsba2pnr16jx58kQkhX8haVUNFUmrnMTERC5fvoyWlhaWlpZKGeQ+Pj74+vpiY2PDwIED0dDQEEWTm5ubUhZLREQEgiC814NLEAQaNmzIqlWrStVT4UORtFYcxAoQXrp06YPGvW3jJRaS1rJHnmX990SRohYs2dnZGBkZoa2tTUJCgqg6ASwsLIiIiODBgweYmJiUeG5MTAyffPIJpqamiqpyMZG0/nOK63VYEgUFBaI9+yUkypKUlBTu3btHVFSUogJdbDIyMordxK5SpYpaNJWG+Ph4zp49S1xcHDVq1MDGxoaGDRuqWxZpaWloaWmhq6tb4nkPHjzg9u3bvHjxgjlz5oik7t28evWKH374QbH++zdt0EtISLwfaWlpijYf9evXV7MaCQmJsiQpKQknJyd8fX0RBIEtW7bQoEGDUv0OVe9h1K5dm6ysLGJiYj4o6SszM5PatWtTuXLlEhPiyhNSgFBCNAYPHswff/xB7969+fXXX4vdhJHJZAwdOpSzZ8/Sq1cvDh8+LLJSSauqqEhaKxLlIRPofZG0ll/E7EEo8d+lQYMGpKSkEBYWplTFVNT3TZ55Z2hoqGT/KxY1a9YkNzeX+Pj4d9pb5uTkULNmTbVVvUta/zkNGzakd+/e2Nvb06NHjwoRoJCQkJCQEI+XL1+SkZFBZmamIqD9936f6iQpKYn09HTq1q1bor28nNTUVAAMDAxULa0QFUmrxH+PwMBAdHV1sbS0VLcUCYl/JampqZiZmZGVlVUue3137NiRhw8fsn//fr744otSj/fy8mLEiBGF2lOUZ1TvhSch8f+ZNm0afn5+nD59mv79+7Nw4cJCzTqvX7/O0qVLuXDhAoIgMH36dEmrpFUtWisSw4cP/8c+3mIhaf1v4ebmRmpqqpI14KpVqxAEARcXFzUqK4ykVRzMzc25dOkShw4dYurUqSWeK7frVdeCoWrVqsTHx3Pr1i06dOhQ4rm3bt0CUFtQSdL6z5k7dy6+vr6MGzcODQ0NrKyssLe3p2/fvtSpU0fl7y9R/nj16hUymYyqVasqvZ6bm8vx48e5d+8eaWlp1KlTh+7du9OmTRu16ExKSuLx48d06tRJ6fX8/HyOHz9OQEAA0dHRaGtr07RpUxwcHN753VM1aWlphIeHExkZSXp6OpmZmQrLxjp16mBqasrHH3+sFm0ODg7o6emxZMmSCuMKUVBQwPPnz2nUqFGhY9euXSt0DfTp0+eDLLPEIDs7m2fPnim+W2L18yuKa9eucerUKS5evEh4eDjp6emFztHV1aVp06bY2NgwaNCgQmtbMTh8+DCrV68mNDQUAE1NTXr37s38+fMxNzcvdly9evXQ0NBQVGqJQUXSWpHIzMwkICBAYTFa3L3VzMyMLl260K1bt3dWGauK8PBwTp06xZUrVwgNDSUpKYmMjAw0NTWpUqUKNWrUwNTUlNatW9O7d28sLCxE1yi3GB0yZAg///wzlStXFl1DacnMzCQ0NBSZTEaTJk3Q19dXHEtMTMTd3b3QvKV///5q2+9ITU3lzz//JCwsjIiICDIyMnj9+nUh+2YrKyu1zQcqGvfu3ePx48eFLMZfvXrF7t27i5wPDh48WC1uKAYGBlhZWfHHH3+I/t7vw5AhQ1i6dCnTpk1DR0eHXr16vffYs2fPKnpVDx06VIUqyxapglBCVNauXcvSpUsVDyEDAwPq1q2LIAhERUWRkpKiaJ68ZMkSZs2aJWmVtKpcU9u2bQkLC0MQBMWiw8HBodS/RxAEPD09y1qehIQoqKKCsChrhvJamSlpFYfDhw8zYcIEdHV1WbdunaKf29/1h4eHY2try8uXL1m3bh3jxo0TXev48eP57bffaNu2LZ6ensVuDmRmZuLg4MCNGzfo27cvHh4eIiuVtJYlqampnDlzBh8fH86ePUtqairm5ub06dMHOzs7PvvsM1F0SKiH/Px8Vq9ezd69exWWQMbGxnz77bc4OjoSGxuLg4MDYWFhgLI1bZ8+fdi2bdsH9YT9EFJSUpg/fz6HDx+mRYsWXLhwQXHs8ePHjBw5UrEJL59bv631f//7n6ibbikpKezatYuTJ09y9+5dhabisLCwYPDgwTg6OiptdKoa+fNIV1eXVatWMWbMGNHeu7Tk5uaydu1aduzYQZ06dZSugfj4eMaPH6/0mhxNTU0cHR358ccf39kXvix58uQJBw4c4MGDB8hkMj799FMcHR0VdtOrVq1iy5YtpKWlKcZ88sknfP/99x+Uwf+hxMbGMnHiRMVn965rFf76bvXs2ZOtW7eK1ut16dKlrFu3rkiNenp67Nmzp9g+nmLPHSuS1opCQUEBa9aswc3NTfHZlHS9yq/TqlWr4uzszIwZM8SQCbxJDJk9ezZHjhxBJpO983sl19q2bVuWLl3K559/LoZMQLm3e5MmTdiyZUuhJJzyQlpaGi4uLhw5coScnBzgTeLCpEmTWLJkCY8ePcLBwYGEhASlz1wQBCwsLDhw4ICoCSN//vknq1ev5sKFC+Tn5wNFX7Pyv7+mpibdunXDxcWFdu3aiaazIhEZGcmUKVO4dOkS5ubmXLx4UXHs8uXL/N///R9JSUmFPmdBEGjVqhW//PKLWpKGFi9ezPr167l69Wq5qyDMzc2lb9++XL9+HUEQaN68OT179qRly5bUqVMHfX19tLW1yc7OJj09nRcvXnDv3j38/PwICQlBJpPRqVMnfv/9dypVqhi1eVKAUEJ0zp07x4oVK7h+/XqhY4Ig0LlzZ1xcXNTSw+nvSFpVQ3nT2rZtW0JDQ5UWHR+yuaPuRUtcXBxBQUH07NlTYduWlpbG4sWLCQgIoKCgQJGhqW57Fklr+UMVAUJzc3MiIyMZNmwYNjY2AEyZMgVBENi6det7bbjIGTFiRJnpKgpJq3iMGjWKkydPIggCLVq0oGPHjuzatQtBEFi+fDnBwcGcPHmSzMxMrK2t8fT0VEtm4+PHj7GysiI3NxdTU1NcXFywtbVVbKinpKTg5+eHq6srjx49QhAEfHx81LKBIGlVDfn5+Vy6dAlfX198fHx4+vQpxsbG9O3bl759+9K1a9d32qRKVBwKCgoYMmQIf/zxR5GbKGvXruXs2bP4+PhgaGiIjY0NNWvWJDQ0lMDAQGQyGe3bt8fHx+e9LPP+Cenp6fTq1UsRaLG1teXo0aPAm0oBa2trYmJi0NLS4osvvqBZs2bo6elx8+ZNfv/9d/Lz82nXrh3e3t6iBIjOnz+Po6MjycnJis/W0NAQExMTqlSpgra2NllZWaSnpxMTE6MIEAmCgJGREe7u7qJtDssDEWZmZjx+/JiuXbuyadOmcldxl5eXx+DBgwkICEAmk2Fpacm5c+eAN9dH9+7defz4MTKZjLZt29KsWTN0dXW5efMmt27dQhAEUZMvDhw4wKxZs8jNzVUKWFerVg1PT098fX1ZunSp4nxdXV2ysrIU5y1atAhnZ2eV63z58iWdO3cmKioKLS0tHBwcsLW1xcLCAhMTE8WmoPx6jY6OVmwKenl5kZOTQ6NGjQgICFD5uiAgIIB+/fohCAJjx47F2dkZIyMjbt++zdKlSxU2iQEBAUXO78UMulUkrRWFgoICvvzyS86dO4dMJsPY2Jhu3bphbm5OnTp1Ct1bo6OjuX//Pv7+/kRHRyMIAnZ2dhw8eFDlWnNycujRowfBwcFoaWkxePBgOnbsiLa2Nnfv3uXAgQOkpaUxa9YsLC0tef78OTdv3sTPz4+UlBQ0NTX56aefGD9+vMq1wl/Xm5ubG/PmzSMtLY0xY8awYMGCcmUrnJWVRa9evRRJN4IgKIIWgiAwb948AgIC+PPPP2nQoAEODg6Kecvx48d5/fo1zZo1IyAg4IP6rJWW1atXs2LFCgoKCoA3/SXNzc0V91YtLS2ys7NJS0sjJiaG+/fvK9pMaGpqKiq6JP4iISEBGxsbYmJi0NDQYPjw4WzZsgWA58+fY21tTWpqKh9//DFjx47FzMwMPT09bty4wb59+0hJScHU1JSAgADR3WWSkpKIjo6mWbNm5XI9lZWVxcKFC3F3d1d8p96FTCZDV1eXcePGsXjxYnR0dERQWjZIAUIJtREfH09wcDDJycloampSs2ZNWrZsWcjGpzwgaVUN5UXrkiVLiI2NBWDr1q3Am0XshyCvhhGb5cuXs379egoKCnj8+DE1a9YE4IsvvuDixYtKC/HWrVvj5+entkwWSWv5RBUBwpUrVyqsL/8pqt4QkLSKR15eHsuWLcPNzY2cnBwEQVD6LskXuMOGDWPNmjWiVo78HV9fXxwdHUlPT1d83vr6+giCoNjAlslkaGpqsnLlSiZNmiRp/ZdpfZuQkBC8vb3x9fUlKCgIPT09unXrhp2dHb179xatYkRCNezZs4dZs2ahra3Nt99+y6BBg9DX1ycwMJBvv/2WnJwcXr9+jampKSdPnlRUPcEbi/yhQ4fy8uVLfv75Z0aPHq1SrUuWLGHdunXUqFGDbdu2YWtrqzj23XffsWXLFho3bsxvv/1G06ZNlcbeuXOHgQMHkpycjKurq8q/Xw8ePKB79+5kZmZiamqKk5MTtra21K9fv9gxERER+Pn5sW3bNh4+fIi+vj7+/v6YmpqqVCv8tTEcHx/P0qVL2bJlCzo6OkydOpXZs2eXm/6kGzZsYNGiRVSuXJkff/yRESNGKCwDV61axcqVK6lZsyZ79uyhc+fOSmN9fHwYN24cmZmZ/O9//2PYsGEq1Xrz5k1sbW3Jz8/HzMwMe3t7xXfr3LlzWFhY8OzZM3Jycli2bBnDhw/no48+IjIykvXr17N7924EQeDs2bMqt/B81/enJJ48ecLgwYN5+vQpM2bMUAp4qoLhw4fj7e3N4MGD2b17t9IxeQDZ39+f1q1b4+/vX2jeKGbQrSJpff36dZn8HlXbUrq5uTF//nwqV67M2rVrGTZs2Hsl1MlkMg4fPoyzszOvX79m9erVTJgwQaVa161bx5IlS6hZsyYnTpygZcuWSscjIiLo27cvL1++5NKlSzRu3Bh487dYt24da9asQVNTE29vb1Esst++3qKjo5k+fTp+fn4YGhoye/ZsJkyYUC6eBRs3buSHH37A0NAQV1dXBgwYgK6uLtevX2f8+PG8ePGC/Px82rRpw6lTp5TWVM+fP8fe3p6oqCiWLVum8tY+Pj4+imfNyJEjcXZ2fq9nemhoKBs3bmTfvn0IgsCRI0eU5jz/db755ht27txJw4YNOXTokNJezowZM9i7dy+tW7fmxIkThfZZo6KisLOzIyIigu+//545c+aILb9CkJCQgLe3NxcvXiQ0NJSoqCgyMjLIzs4uZInbuXNn7OzsKuSaUAoQSkhISFRwjh49qrDfMzIy4tq1a1StWpVLly5hb2+Pnp4eK1euREtLiwULFvDq1St++uknJk6cKGn9l2gtC1QRIJTJZOzcuZPz58+TkpICwKVLlxAEASsrq1L9Li8vrzLTVRSSVvFJSEjgxIkT3Lp1i/j4ePLz86lWrRoWFhY4ODjQpEkTtWl7m6ioKNauXcvJkydJSkpSOqanp4etrS2zZ89WW/+xt5G0ikdiYiI+Pj74+Pjg7+9PVlYWlpaW2Nvb8+WXX1K3bl2Vvn9ZBKAEQcDd3f2fi3kHFUVr7969uXr1KosXLy5kcb9//36mTZuGIAj88ssvRVrRu7u7M3PmTKysrPD29lap1tatW/Ps2TPc3d0ZMGBAkccOHz5cbM8Uud1zmzZtOH/+vEq1jhs3jqNHj9KzZ08OHjxYqizxvLw8hg8fzpkzZxg6dCg7duxQodI3/D0QcfXqVaZMmUJ4eDjVq1dn6tSpTJgwQe2uER06dODRo0ds2LChkA1qx44defjwIbt27WLw4MFFjt+xYwfffvutKNfr2LFjOXbsGD179sTDw0OpanX27NkKF4F58+Yp9VeWM23aNPbv38+QIUPYuXOnSrW2atWK58+f4+XlVeo5FaBYJzRq1Ijbt2+XvcC3aNq0KYmJiQQGBvLpp58WOh4XF0fbtm1JS0tj48aNjBo1Sum4mEG3iqRV/l7/hLdbl6gKa2tr7t27h5ub2wc5ghw4cAAnJydatWpVpBVxWSLXumPHDoYMGVLkOSdPnmTUqFEMGzaMbdu2KR1bunQpa9euZcCAAezdu1elWqHo6+2XX35h6dKlxMXFUbVqVcaPH8+YMWNUPt8riS5dunDnzp0iE5OOHTvG2LFjEQSB48eP061bt0Lj5ee8XYGuKuQJ1jNnzmTJkiWlHi+3o+zatSsnT55UgUJlKsrc9dNPP+XFixccO3aM7t27F3msJCcWeeD2008/5c8//1SpVonyjRQglJCQ+M9TlrYa6rDrs7Oz488//2TChAmsXr1a8fqcOXPYvn07U6ZMYdWqVQB4eHgwefJkOnXqhK+vr6T1X6K1LFBFgLAoKpJFkKRV4u9ERESQkJBAXl4e1apVo3Hjxiq3EvxQJK3ikZ2dzfnz5/Hx8eH06dOMGTOmyE3ussTU1JT4+HilTczS2AuDeNboFUVr/fr1SU1N5f79+9SpU0fp2PPnz7GwsEAQBB4/foyRkVGh8VFRUXz66ad8/PHHPH/+XKVaa9asSW5uLlFRUYWqrI2MjMjJySE2NlZRUfZ30tPTFT1UXrx4oVKtZmZmxMfHc/369Q+qAHz06BHt27enVq1aPH78WAUKlSnqeZqTk8P27dtZv349iYmJVKlShSFDhvD111+rvKKtOOR/56dPnxaqCqhVqxbZ2dlERkby0UcfFTk+OTmZRo0aYWhoqLBwUxWffPIJsbGxXLx4EXNzc6Vjt2/fpkuXLgiCwI0bN4pMDrp//z6ff/45devW5f79+yrVKv9c4+LiPsgaLDs7GyMjI3R1dYmLi1OBwr+oUaMGeXl5xMfHFxt4//nnn1m4cCG1atXi9u3bSlVtYs4dK5LWhQsXcvjwYUUf2g9FnsSnKoyNjcnMzOTFixcfVM0mfw5UqVKF6OhoFSj8izp16pCRkVHkM0tOWloadevWxcjISNE/V05MTAyffPIJtWvX5tGjRyrVCsVfb1lZWWzdupWff/6Zly9foqmpSffu3Rk4cCD29vai9vWFvz7XouYlL168oEWLFgiCoEhw+TtxcXGYmZlhYGBAZGSkSrU2aNCAlJQUQkNDFa5MpSE+Ph5TU1NR5lhQceau8vlgTExMIZtY+bGS7rtZWVnUqlWLypUr/+N7nkTFpmL6oElISEiUIfLeXf8EuSWeOgKE9+7dAyjUl+PixYsIgkC/fv0Ur8kzyUNCQsQT+BaSVgkXF5d//H376aefcHR0VHkPCElr2WNoaIiGhgZxcXHlstfAu6hfvz7169cnJyen3OuXtIqHjo4Offr0oU+fPoDqNwXhTS9HX19f5s+fz9OnTxEEAUdHxw/adFE1FUWr3FauqD7UtWvXVvx/UcFBeJNoA5CRkaECdYXfKy4ujoyMjEKbrfr6+iQnJ5Ofn1/sePnzorSbXR+CfHOsJEvRkmjYsCEgzveqOLS1tZk2bRpjx45l8+bNbNmyBXd3d/bu3Uu9evX44osv6NatG1ZWViq3FZTz0UcfFaq+lqOrq0t2dnaJ91O5zpycHJXoe5vExESAIu065VaC8GYDuSjk58THx6tAnTLVqlUjNjaWZ8+e0axZs1KPl29ci9Eyw9DQkKSkJOLi4ortkenk5MSePXt49uwZixYtUkp6FJOKpHXp0qUsWLCAOXPm4O7urqjAKi/OFnJ0dXXJzMwkLS3tgwKE8meeGPMu+TOnpLWKvLK4qHu9PNEhOTlZBereH11dXZydnXF0dGTLli3s3buXs2fP4ufnx/Tp02ndujVdunTB0tKSVq1aqbx3rfz+XdTf8O25SnFrO/lzQN7vVZXk5eUBfHCvQ7lW+e9RNRVl7mpkZMSLFy9ISEgoNM+qWrUq8fHxvH79usQAIVDu2uTI9wxUXYkt8Rfl6wqQkJCQUANWVlZFTlZzc3O5evWq4mdDQ0Pq1auHpqYmz58/V2x4GBgYMG7cOLU9VOUbUW/7XL98+ZKHDx+io6OjlNksn1ynp6eLK/L/I2mV+O677/7x73B1daVfv34qD7pJWsue+vXrExkZSXh4OM2bN1fZ+5QleXl57N69m99//52HDx+SmJiITCbj5cuXhIaGsmvXLiZNmkSjRo3ULVXSWsbIq8TLirKsKhQEgb59+2JmZkbbtm2RyWRMnDhR5VXgH0JF0VqzZk1iYmK4f/9+oR5HOjo679ysDgsLA/4KFKqS9u3b4+npyb59+wr1jOnYsSPe3t5cuHCBvn37Fjn+7NmzAKJ8v+rUqcPTp0+5evUqNjY2pR5/7do1xe9RN1WqVMHFxYUpU6Zw6NAh9u3bx927d3Fzc8PNzY1KlSrRrFkzWrduzZYtW1SqxcLCgvPnz3Ps2DEcHR2VjrVu3ZqAgACuX7+OtbV1keMDAwMBRLHHq1y5Mqmpqbx48aJQkPCjjz6idevWQPEblPLAYHEVsWWJjY0Nhw4dYu7cufz666+l2szOzs5mzpw5CIJA165dVSfy/9OmTRvOnj3L9u3bWbZsWZHnaGlpsW7dOgYOHMiOHTvo2rUr9vb2Ktf2dyqSVngTcPnpp584fvw4qampGBsbf3CSg6po1aoV/v7+rF+/HldX11KP37BhA4AoVu6mpqbcunULX1/fYm2P5fekt/v7ypHbXxZ1TB0YGBgwf/58XFxc8PX1Zd++fZw9e5YbN25w8+ZNQBybWWNjYyIiIrh582Yhe0ktLS0OHTpU4nh5crMYQa+mTZty584djh49+kH2nSdOnAAQpRcxVJy5a+fOnfn1119xc3MrtG6xsbHhyJEjnD17tlhr31OnTgHifa6lQYwkNom/eHcHWwkJCYl/Od7e3nh5eSn9d/LkScUitFu3bpw+fZqIiAgCAwO5cOECz58/58KFC/Tp04fU1FRu375dJhv0H4I8gPXs2TPFa+fOnUMmk9GuXTulbCG5jZS6mmpLWlXDwYMHS2WV6+HhUajfjIuLS7nLiCuOijRZlLQqM336dGQyGbt371b5e5UF4eHhWFpaMnfuXAICAoiLiyM/P1/xWaWnp7N161Y+//xzfv/9d0nrv0zrypUrWbVq1Xv/V9z58tdVQZMmTbC0tFTJ7y5ryrvWDh06IJPJWLBgQZHZ9BMnTiyxz/DPP/+MIAii/BunTZuGhoYGq1atws3NjYKCAsWx2bNno6GhwQ8//FBkhdmTJ0+YP38+giAUu1FblvTr1w+ZTMbUqVN58OBBqcY+ePCAqVOnIggC/fv3V5HC0mNgYMCECRO4ePEily5dYvz48dSvX5/c3Fzu3bvHgQMHVK5h8uTJiuv17/2Ep02bhkwmY+HChUVey8nJyYpr4IsvvlC51hYtWgBvenj9HUEQCAgIICAgoNjxcvt+MTYw58yZg76+PgEBAbRv357Nmze/09Lw4cOHbN68mXbt2uHv789HH33E3LlzVa51zJgxyGQyNm3axIwZM7hx44aiKuxtunfvzoQJE5DJZIwbN47du3eXWGH8X9cqR0dHp9gAe3lg+vTpAGzbto0xY8a8d8/L27dvM2bMGNzc3NDQ0GDmzJkqVPmGoUOHIpPJcHFxUbj0vM3z588Vbih2dnZKx/z9/Zk9ezaCIBTquatuNDQ0sLOz49dff+Xhw4e4ubkxZMgQatSoofRcVhWdO3dGJpMxb948RaX227ztblEUK1asQBAEOnbsqEqZAHz99dfIZDLmzp3Lzp0737sSMC8vj127dvHtt98iCEKZ9AYsDeV97jpr1ix0dXX53//+x7x585QqcF1cXNDV1eX7779XJLG9zdWrV1mwYIHanNAkyhdSD0IJCQmJIli7di3Lli1jyJAh7Nixo8Rzp0yZgoeHBwsXLmT27NkiKfyLUaNGcerUKQYNGsTu3bvJzs6mV69e3Llzh+XLlzNt2jTFufPnz8fNzY327dsrssclrRVfa2ktGOrXr4+GhoZS8LMiIVa/xLJA0lqYlStXsnr1asaPH8+ECRPKZcYivLE4srKyIjIykiZNmjBnzhwsLS1p166doqdEamoqzs7OHDlyBF1dXQIDA4u0UJO0Vkyt+/btIzIykrVr15Kfn0+lSpVo3rw5devWRUtLi4iICEJCQsjOzkZDQ4P+/fuXWG2ydetWleicO3cu27dv58qVK+X+XlOetd68eZOePXuSn5+PiYkJDg4ONGjQgKlTpxY7Jjo6mvDwcPbu3ctvv/2GIAgcO3asUCa/Kti+fTsuLi7IZDLq1q2Lvb09bdq0oUGDBnh5ebFx40aMjIwYN24cLVu2JCcnh6tXr3Lw4EHS0tKwsLDgjz/+ULm9XFpaGjY2Njx58oRKlSrRs2dPbG1tMTc3x8TEBH19fbS1tcnOziY9PZ3o6GiCg4Px8/PDz8+PvLw8TE1NCQgIECUR65/0Onvy5Annzp3D39+/yGBYWbNo0SI2bNiAIAi0b9+e/v37Y2lpSf369RU9E1u0aMG0adOUrgE3NzdevHhBvXr1+PPPPzEwMFCpzt27d+Ps7IympiZOTk4MGTKEBg0avFe/rvPnzzNq1CjS0tJYsmSJKMGMy5cvM2bMGGJjYxUuM1paWhgbG6Ovr4+WlhY5OTmkp6cTGxtLbm4u8CbRytjYmL179xaqQlYV3377LTt27FCycNy1axeDBg1SOi8vL48RI0Zw+vRpBEHgo48+IjU1VdT+1RVJq5zly5ezevVqrl69Wu6eWQBbtmzhhx9+UASjqlevTsuWLRU9Zv9+b7137x5JSUnIZDI0NTVZsWIFkydPVrnO3Nxc+vbty/Xr19HW1sbBwYHPPvuM7OxsHj16xKlTp8jOzqZ27doEBgYqEnUHDRqkSNBt3rw5Z8+eLbavallSFj0v79+/z6efflp2ooogNDSULl268Pr1a/T09OjSpQsNGzYsMSnt6tWrhIWFsX//fi5fvoympiZnzpwRpZ/u//3f/+Hp6YkgCFStWpUuXbrQsmVLTExM+OijjxT31rS0NMX1GhAQwKtXr5DJZAwcOBB3d3eV6/w75XnuCuDp6cnEiRPJzMykcuXKdOnShTZt2lC/fn1u3rzJ//73P/T09Bg4cCCffvqpwintzJkz5Ofn0717d44dO/aP25WUJWL2nZV4gxQglJCQkCiCDh068OjRI27cuPHOfgNPnz6ldevWmJmZcf36dZEU/sXVq1fp3bs38MaDvKCggISEBPT19bl79y7Vq1fn4sWLLFmyhKCgIOBNtpiTk5OktYJqjYyMJCIiQvGznZ0dgiDg7e39ziqwiIgInJyc0NHRITY2VtVSVYIUdFMNYmj96quvALh7966iEXqVKlX4+OOP0dTULHbc3bt3VaapOFxdXVmxYgWtWrXCy8tLsSFR1IJl8uTJeHh4MHbsWIVlk6S14mtNTk7G2tqa6Ohoxo4dyzfffFPIji8+Pp41a9awbds2LC0t8fX1Fb2P4p07dwgMDGT48OGi9L36J5R3rUeOHGHmzJkKy/B3bU7UqVOHjIwMxbP322+/5YcffhBDKvCmL/IPP/zArVu3gJL7O8FfPbMHDx7M+vXrVR4YkpOUlMTUqVPx8fEB3q0T/qpqd3BwYOPGjSq36pZT0TalPDw8WLp0KdHR0e+9uSeTyWjfvj179uwRxWK0oKCAESNG4OPjoxQcKimxbciQIYSEhBAVFYVMJqNly5b4+fl9cP+q0vL69Wvc3d05ceIEQUFBJVaxVapUibZt2zJw4EBGjx4tmkY5J06cYPPmzdy8eZP8/Hz27NlTKOgGkJ+fj6urK1u2bHnve9x/WSu8CWy9fv0aAwODcrV5/ja3bt1i9erVnD17tlBPUUEQCq0NdXR06NWrF99++63C3lcMXr16xaRJkxQVwX/vhdukSRMOHDig1ILAysqK0NBQRo4cyY8//ihaj9eK9By4dOkSEydOVDgavUu3iYkJr1+/RiaTUalSJdasWcPYsWNFUgubN2/m559/VlhHl/S9kl8btWrVwtnZmSlTpoii8e+U97krvAkWL1u2DE9PTwoKCgp9rvL539s/V65cmSlTpvDdd9+Vyx6E6v4OlkW1qiAIaglqfwhSgFBCQkKiCGrVqkV2djYJCQmKhtnFkZubS40aNdDV1SUuLk4khcq4u7vj4uKisBGqUqUKmzdvViy4Nm3axIIFC4A3XuTHjx9X2yRA0vrPWbly5Qf1mpAjt0n18/MrQ1XiIQXdVIMYWg0NDUs9Rl2LAysrK+7fv4+XlxdWVlaK14tasISEhNCxY0caNGiglmCmpFU1zJs3j61btzJjxoxieybJWbx4MRs2bGDevHll2mtQQnySkpI4evQoN27cID4+nuPHjxd7rrGxMfDG5mvKlCl069ZNLJlK3Lp1i9OnT3P79m3CwsJISEjg9evX5OfnU6VKFapVq4apqSmdOnWiX79+aqvcDg4O5vjx41y6dInQ0FCSk5MLnVOtWjXMzMywtrZm4MCBtGzZUlSN5WFTqrTk5OTg4+OjuAbCw8MLWYtqa2vTqFEjOnXqRP/+/UWpcn0bub34vn37uHfvHnl5eUpWaH/HxMSEjIwMNDU1GTRoEKtXr1bbxmxWVhZPnz4lMjKSjIwMsrOz0dHRoUqVKtSrV4/GjRujo6OjFm1vk56ezvPnz6ldu3aJAfXMzEz8/f25c+cOL168YNOmTSKqfENF0lpReP36NVevXiU0NJSoqCjS09PJyclBW1sbfX196tati5mZGe3btxct0FYUV65c4ffffyc0NJScnByMjY3p2rUrAwcOLLTvcu3aNVq2bCm63smTJyMIgsqcH8qavLw8/Pz8uHHjBgkJCSUm1dWvXx8jIyO6du3KxIkTMTMzE0/o/ycnJ4fAwEAuXrxIWFhYsfdWU1NTOnfujJWV1Tv35CTekJiYyJkzZxTzwcTERDIyMhTzwerVq9O0aVM6depEr169PmhtLgblYS5mampKfHx8ocBqaVD3v6E0SAFCCQkJiSJo2LAhr169IjAw8J3WEMHBwVhbW1O9enWePHkiksLCJCYmcvnyZbS0tLC0tFTqJ+fj44Ovry82NjYMHDgQDQ31tqCVtP4z3NzclBYsERERCIJAvXr13jlWEASF9Yi8J0xFQwq6qQYxtF66dOmDxqmjB4w8w/bviSJFLViys7MxMjJCW1ubhIQESeu/RKuFhQURERE8ePAAExOTEs+NiYnhk08+wdTUVFFVrir+ngVcnvm3a42JiaFWrVpqn6tUVDIzMwttCopdffV35A4N9evXV6uOf0paWpoiSFy5cmUMDAzKzXWam5tLcnIytWrVKvacDRs2UK9ePWxsbCpMj2wJCQmJ8k5FmpdJSKgTmUyGr68v8+fP5+nTpwiCwLhx40o9J5k/f76KFJYtUoBQQkJCoggGDx7MH3/8Qe/evfn111+LnUTJZDKGDh3K2bNn6dWrF4cPHxZZqYRE+ciwEhMp6KYaKpJWMWjQoAEpKSmEhYUpeqFA0d+3iIgIzM3NMTQ0VLL/lbRWbK01a9YkNzeX+Pj4d9qG5uTkULNmTVHcBBo2bEifPn2ws7OjR48eovRl+1AqmtbevXtjb29f7rVKSEiIS3JysqLK5fXr14qAdt26dTEyMlK3vBLJyckhKCiI2NhYatSoQbt27dQaiM/Ly+Pu3btkZGTQoEGD9wrG37t3D0D0iuL3Yf78+QiCwIoVK9QtpRDy5IvywMGDB9HT02PAgAHlPkBVkbRKlA/K8z1K4p8RHh5O27Ztkclk5bYPZVlQvkxmJSQkJMoJ06ZNw8/Pj9OnT9O/f38WLlxYqHHz9evXWbp0KRcuXEAQBKZPn64mtRL/dYYPHy4tXiTKHW5ubqSmpirZLa5atQpBEHBxcVGjsvfD3NycS5cucejQIaZOnVriuXK7XnUtGCStqqFq1arEx8dz69YtOnToUOK58h5wYgSV5s6di6+vL+PGjUNDQwMrKyvs7e3p27cvderUUfn7lwZJq/o4c+YMvr6+CrvJatWq8dlnnzF48OB39tdWNSEhIYSGhhIREUFGRgaZmZkKG7w6depgZmaGubm5WrRZWFigp6fHypUrRbfh/K8QFxfH5cuXFQGidu3avTOI4e3tDbzpuy0GBQUFHDt2jFOnTnHx4sUS+yUaGBhgY2PD4MGDRQ8oREVF4e7uzr179xAEAQsLC8aPH6+ocDh+/Dhz585VqsKvXLkyzs7OzJkzRzSdctasWcPPP/9MWlqa4jVzc3MWLVqEra1tseOsrKzQ0NAo8e+gLtzc3NQeIHzx4gVeXl4K+2Z5MFtuh6enp6e4t9rY2NCvX793OiOUNVOmTEEQBHbu3MmuXbuoXbu2qO9fGt7Wunv37hKrncsLT5484cGDB8hkMlq0aKH0nH/06BFbtmwhODiY9PR0TExMsLW1ZezYsejr66tFb0hICBcvXlS6Xv+efGFqakqXLl3e6ehVHlD3PSo/P5/Tp0/z9OnTQuur8PBwNm3ahL+/PzExMWhra9OkSRO++OILJkyYIFo/6vehPM5dmzRpgqWlpcodYtSNVEEoISEhUQxr165l6dKlikWegYEBdevWRRAEoqKiSElJUUy6lyxZwqxZs1SuqW3btoSFhSEIgmLy4eDgUOrfIwgCnp6eZS1PCUmrhKqoSJVu/2WttWvXJisri5iYGEWmekWqdj18+DATJkxAV1eXdevWMXLkSKDwvyE8PBxbW1tevnzJunXrGDdunKT1X6J1/Pjx/Pbbb7Rt2xZPT89ie+BkZmbi4ODAjRs36Nu3Lx4eHqLoS01N5cyZM/j4+HD27FlSU1MxNzdXVOx99tlnouh4HyStZY+pqSkaGho8evRI6fWYmBhGjx7NtWvXAOV+KYIgoKGhwbhx41ixYsU7K2PLkidPnrBx40Y8PT1JSkp65/nVqlVjwIABzJo1S1S7T/m9SBAEnJ2dmT9/vtT7qIzIzs5mzpw5/PLLLxQUFCher1mzJt9//z1jxowpdqyhoaFom6/3799n9OjRhIWFKX1/qlSpQpUqVdDW1iYrK0sR3JYjCAItWrRg7969ovT5PHHiBJMnTyYrK0uhUxAEjI2N8fT0JCQkhFGjRlFQUEC1atUwMTHhxYsXvHz5EkEQ+Prrr0Xt6Tdp0iQOHTqETCZDR0cHAwMDReBSU1OT1atX4+joWOTY8jx/VKe2jIwMXFxc+PXXX8nLy3uv/liCIKClpcWoUaP48ccf0dXVFUHpX58TvEnAcnV1ZejQoaK8d2mpSFpfvHjBpEmTCrVxGDBgANu2beP27dsMGjRIKWAMb64DExMTDh8+LGrV26+//sqaNWsICwsDSu7pJv8bNGvWjPnz5zNgwAAxJH4Q6rwP3Llzh3HjxhEeHo65uTkXL15UHDt+/DhTpkxRek7IEQSBunXr4uHhIVpSVkWbu8qZO3cu27dv/1dXEEoBQgkJCYkSOHfuHCtWrOD69euFjgmCQOfOnXFxcRGtP1bbtm0JDQ1Vmnx8SGNhMSYvklbxiYuLIygoiJ49eyomTmlpaSxevJiAgAAKCgro3bs38+fPL1eZYqXlvxx0UyVlrdXc3JzIyEiGDRuGjY0N8FdG7tatW0vV5HvEiBFloqm0jBo1ipMnTyo2/Tp27MiuXbsQBIHly5cTHBzMyZMnyczMxNraGk9PT7X1eJK0lj2PHz/GysqK3NxcTE1NcXFxwdbWlo8//hiAlJQU/Pz8cHV15dGjRwiCgI+PD506dRJda35+PpcuXcLX1xcfHx+ePn2KsbExffv2pW/fvnTt2lUtC+qikLSWDUVtRqWnp9OtWzdCQ0MB6NGjh6JPdmpqKleuXMHHx4f8/Hzs7e05cOCAKFoPHjyIs7Mz2dnZiuCAmZkZJiYmioBLdnY2aWlpxMTEEBoaSk5ODoIgoKenx5YtWxg0aJAoWuWfq42NDQEBATRv3pxNmzbRrl07Ud7/30pBQQEDBw4kICAAmUxG/fr1qVmzJmFhYaSkpCgCsosWLSpyvFibr5GRkXTu3JmXL19SrVo1Ro8eja2trcLu+u+8fPmS+/fv4+fnx/79+0lMTKRmzZpcunRJpRVS9+/fp2vXruTk5NCyZUv69OmDpqYmvr6+3Llzh08++YTk5GRevnzJhg0bGDlyJIIgIJPJ2Lt3L9988w35+fkcOXKkxMq9suLkyZOMGjUKDQ0NFi5ciJOTEzo6OsTExLBgwQKOHDmCpqYm3t7edOzYsdB4MTffGzduXKrzk5KSEASBatWqKV4TBIHw8PCylqZEVlYWvXr14u7du8hkMtq2bYutrS0WFhaYmJigr6+PlpaW0r313r17/PHHH1y/fh1BELC0tMTHx0eU55j8b/j777/j5OREREQEPXr0YNWqVaIE1EtDRdH66tUrbGxsiIiIQCaTYWRkhL6+Ps+ePUMmk+Ho6MiVK1e4d+8elpaWDB06lJo1axIaGsqePXuIjY3FxMSEwMBApetXVUyfPp39+/cjk8nQ1dWlbdu2mJubU6dOHaXki/T0dKKjo7l//z5BQUFkZWUhCAITJkxg9erVKtcJ8MMPP5Tq/I0bNxZyFRMEgaVLl5a1NCWePn1Kly5dSElJwdDQkAkTJii0v/2caNy4MdOnT6dZs2bo6upy48YNNm/ezPPnz6lVqxaXL1+mevXqKtUKFWvu+jZ37twhMDCQ4cOHU7VqVdHfXwykAKGEhITEexAfH09wcDDJycloampSs2ZNWrZsKfrDYcmSJcTGxgKwdetWgA9+QMqrNlSFpFVcli9fzvr16ykoKODx48cKa6EvvviCixcvKmUWt27dGj8/PypVqphO4//loJsqKWutK1euVFiK/lPUFXjPy8tj2bJluLm5KTar3/4uyWQyBEFg2LBhrFmzRm02PZJW1eHr64ujoyPp6emKa1lfXx9BEBQWaTKZDE1NTVauXMmkSZPUpvVtQkJC8Pb2xtfXl6CgIPT09OjWrRt2dnb07t1bqf+jupG0fhhFbbKsWrWKlStXYmhoiIeHB1ZWVoXG3blzh4EDB5KcnMyOHTsYMmSISnVeuXIFOzs78vPz6dy5M7NmzcLGxqbEDemcnBwuXLigsMTS0tLC19e3kN2/Knj7c92+fTuLFy/m9evXDBkyhEWLFlG3bl2Va/g3snfvXmbMmIGOjg5bt25l8ODBwJsKbFdXV9avX48gCBw4cAB7e/tC48UKEM2YMYO9e/diaWnJb7/9VqoN01evXjFo0CBu3rzJ2LFjWb9+vcp0yivc7e3t2b9/P5qamsCbQOz//d//4eXlpdisXrZsWaHx8+fPx83NDXt7ew4ePKgynXL69+9PQEBAsRv8jo6OHDlyhEaNGnHt2rVC9wcxA4T169cnJSXlH/0OMbTK59k1atRg7969pUpYvnz5MqNGjSIhIYHvv/9eFLvZt/+GGRkZLFiwgD179lCpUiW+/vprnJ2dRa0WL4mKonX58uWsXr0aY2Njdu/ezeeffw5AdHQ0X331FcHBwQB0796dI0eOKCXbpaSk0Lt3bx4+fMjcuXP57rvvVKr1wIEDODk5oampydy5c5kyZcp7JWSnpqaybds2Vq1aRX5+vijzFlCuIgUUa5PieHsd8/b5qr4PTJo0iV9//ZXWrVvz22+/KfXEld9Xu3fvzuHDhwu5IaSlpWFnZ0dwcDAzZsxQeTATKs7c9b+IFCCUkJCQkJCo4Bw9elRhv2dkZMS1a9eoWrUqly5dwt7eXtFLR0tLiwULFvDq1St++uknJk6cqGblH8Z/OeimSspaq0wmY+fOnZw/f16x0XLp0iUEQShy4l8SXl5eZaLpQ0lISODEiRPcunWL+Ph48vPzqVatGhYWFjg4OKi9n9fbSFrLnqioKNauXcvJkycLWSPq6elha2vL7NmzadOmjZoUlkxiYiI+Pj74+Pjg7+9PVlYWlpaW2Nvb8+WXX5argIek9f0papOlY8eOPHz4kPXr1zN27Nhix8o36rp06cKpU6dUqvOrr77C19eXESNGKJKwSsOUKVM4ePCgaIGMv3+u8n4+gYGBaGtrM2LECGbMmFEu7k+lrXAoCjEqHAD69OnDlStXmD9/fpF9iL///ns2b96MkZERN2/e5KOPPlI6LlaAqEWLFkRHR+Pv70/r1q1LPf7WrVt07dqVunXrcv/+/bIX+P9p1qwZcXFxBAYGFurP9eDBAzp16oQgCFy/fr3IiqdHjx7Rvn17jIyMFFUbqqRhw4a8evWqWD1paWm0adOGhIQElixZwsyZM5WOixkgjI2NZfLkyZw/fx5BEBg3blyxFcwymQwHBwdFtdnbqNphqF27doSGhuLh4UHfvn1LPd7Hx4dhw4bRrFkzha2fKinqbxgQEMD3339PcHAwWlpaDBo0CEdHx3f2fVY1FUVrp06dCAkJwd3dvZD9pvzvKwgCp0+fLlLnmTNnGDJkiKI/uCqxtbUlKCiI5cuXM23atFKP37x5M99//z0dOnTgzJkzKlCozM6dO1m4cCEZGRkIgoCdnV2JAc2DBw8iCALDhw9Xev1D5j2lwdTUlISEBM6cOUP79u2VjpmZmREfH8+FCxewsLAocrx8v6hp06bcuHFDpVqh4sxd3xUQ/jciBQglJCQkKhBluTGiass+Sat42NnZ8eeffxbKyp0zZw7bt29nypQprFq1CgAPDw8mT55Mp06d8PX1FV1rWfBfDrqpEjG0luceMhIS70NERAQJCQnk5eVRrVo1GjdurKjcqAhkZ2dz/vx5fHx8OH36NGPGjGHevHnqllUkktaSKep+Ku/9Gh4eXmLlU3JyMo0aNeLjjz/m+fPnKtXZpEkTkpKSCA4Opl69eqUeHxERgbm5OTVq1FC5ZR8U/5zy9PRk+fLlPHz4EA0NDbp06cLo0aPp06ePos+u2NSsWZPc3NwPHi9WhQO8qcpKTU3l9u3bNGzYsNDxnJwc2rVrx/Pnz5k1axaLFy9WOi7W/MHIyIicnBzi4uLQ0dEp9fjs7GyMjIzQ1dUlLi5OBQrfUKNGDfLy8oiNjS3UQy4zM5PatWsjCEKRx+GNPWWtWrXQ0tIiMTFRZTr/rjchIaHYnp779u1j+vTpGBoacuvWLaV7mDrmj9u3b2fRokVkZmby5Zdfsnbt2iIDBOqa29aqVYvs7GylXt+lQX6d6OnpKZx0VElJn9PRo0dZsWIFYWFhCIKAqakpgwYNol+/foUC4GJQUbQaGxuTmZnJ06dPCzlbxcXFYWZmhiAIREREFNleJCkpicaNG1OlShWio6NVqrVevXqkpaXx7NkzhVV/aXj58iUNGzbEwMCAyMjIshdYBGFhYUyaNImgoCBMTEzYvHkzPXr0KPJcdd0HSnpmyecIiYmJxTpH5eTkULNmTZU/s+RUlLlrw4YNFb3He/ToQZUqVVT6fuUBKUAoISEhUYH4u9XBhyDWZoCkVTzkmy4PHjzAxMRE8bo8G8vb21thOSJfCIgxsVIVUtBNNYihdcWKFQiCwPz58z/4d/z00084OjqqvE+CoaEhGhoaxMXFlZt+aMUhaRWfnJycCq1fjrxnSUVA0qpMUZss8g24+Pj4Eq/P169fY2xsjLa2NgkJCSrVKd/4+aeb2JUrVyYmJkYFCpUpaZNPJpPx66+/smrVKp49e6bokdijRw+6deuGjY2NqP2pUlNT8fDwYNWqVSQnJ79XlUNRqLrCAf7aqCwpQPT7778zcuRIdHV1CQoKUgooi7X5Ku+f/Mcff2BpaVnq8fIKwvr16yvs/VSBvGrk6tWrNGvWTOmYvDpQEARu3rxZZE+9p0+f0rp1a6pVq8bTp09VplPOJ598QmxsLEFBQTRt2rTIc2QyGV26dOHu3bsMHDiQPXv2KI6pa/M9NDSUiRMncvPmTerUqcPmzZvp3r270jnq0ta0aVMSExOLDbq/C3nyhbwXqKp51+dUUFCAh4cHO3bs4NatW4q1ec2aNencuTOWlpa0bt261C4k/2at8iBxWFhYIYvzvLw8qlevXuK/Qx50EyM4JN+vKCqY+T68evWKBg0aYGhoSEREhAoUFk1BQQGrV69m9erV5OXl4ejoyPLlywvNZ9R1H7CwsCAiIqLI6uyWLVsSFRVV5PUhJyEhgaZNm1K1alWePXumcr0VZe7q5uaGr68vf/75JxoaGlhZWWFvb0/fvn2pU6eOSt9bXVTM5kMSEhIS/1GsrKyKDGTl5uZy9epVxc+GhobUq1cPTU1Nnj9/rngAGxgYMG7cOFF6z0laxSMjIwNAaeL38uVLHj58iI6OjlLPHrllU3p6urgi/z/yas33rbT08PDA0NAQOzs7xWsuLi6KHouqRNJa9pRFfwtXV1f69eun8gBh/fr1iYyMJDw8nObNm6v0vf4pklbVkpeXx+7du/n99995+PAhiYmJyGQyXr58SWhoKLt27WLSpEk0atRIbRrlVeJlhSqr3yStqsPS0hJ/f3+Cg4NLDG7cuXMHeLO5qGoaNmzIw4cP8fPz44svvij1+HPnzil+j7qR24cNGzaMM2fOsG/fPk6fPo2np6fCXtDAwIBWrVrh6empcj0GBgZMmjSJdu3a0a1bNwAWLlxYLpOSatWqRVRUFI8ePaJly5ZFnuPg4ECXLl0ICAhg6tSpKrcQK4qePXuya9cuZs2axdGjR5X6Ob2LhIQEZs6ciSAI9O7dW4Uq31gLnjp1CldXV3bv3q10zNXVVfH/p06dYtasWYXGHz9+HKBY27mypl27dnh6erJmzRr+97//FXmOIAhs2LABW1tbjh8/zueff86ECRNE0Vccpqam+Pn58dNPP7FmzRqFrWRRAQKx6dChA15eXixdurTQNfA+LF26FEEQ6NSpkwrUlR4NDQ1GjhzJyJEjefDgAe7u7hw+fJj4+HiOHj3KsWPHEASBly9fqltqudFap04dnjx5wp9//km/fv2UjlWqVIkrV66UOP7u3bvAm0QeVdO8eXOuXr3K7t27+eabb0o93t3dHUD0Kk0NDQ1cXFzo1asXEydOVLTP2LZtG+3atRNVS1H07NmTnTt3smrVKnbt2qV0zNbWFnd3d06ePImjo2OR43/99VeAYp/LYlAe565OTk44OTmRmprKmTNn8PHxYenSpXz77beYm5srqgs/++wzlWsRC6mCUEJCQqKCk5eXx6BBgwgICKBbt27MmzePjh07Kp1z584dVqxYga+vL127duXYsWNqsUSTtKoGeR+Sa9euYWZmBvzVl7Bz585KPTHkGcNiZ9/JkVcPve+CqX79+mhoaIiS0fZ3JK3lE7GqMrdv386cOXOYOHGiknVveUTSqjrCw8MZNGgQz58/Ryb7a9kkz36VV4tUrlyZHTt24ODgoBadpa2EL663hhjV8JLWstW2YMECPvnkE5o3b054eDhDhgzh888/59SpU0VWamVkZNCvXz9u3LjB8OHDVV49tnbtWpYuXcrHH3/Mjh076NWr13uPPXv2LBMmTODVq1csWrQIZ2dnFSp9Q2mrABITE/Hw8MDX15dr166Rk5OjlioCa2tr7t27x5UrV8plgHDixIkcOnSInj17cujQoWLny2FhYVhbW5OVlYWzszOLFi0CxKvOiIuL4/PPPycpKYmPPvqI4cOHY2tri7m5ucK2U05BQQGxsbEEBwfj5+fHoUOHSElJoVatWgQGBqo06erGjRv07NmTgoICOnTogL29PYIg4OXlxZUrV2jQoAGvXr0iLy+PQ4cOKfXD8/f3Z/jw4WRmZrJ9+3aGDh2qMp1yAgMDsbOzQxAEunbtyujRo2nevDkNGjQoFGhbvXo1y5cvR0NDg5kzZ+Lk5ISpqanaLepv3LjBxIkTCQsLo0mTJooAgboqh27cuEHv3r3Jy8ujbdu2zJw5k27duqGvr1/smPT0dM6dO8fGjRsJCgpCS0uLs2fPflC/zdLyIZ+TPFn3/PnznDt3jjt37pCcnKw6kf+fiqJ17ty5bNu2DWNjY44dO0aLFi3ee2xOTg49e/bkzp07fP3112zatEmFSuHIkSM4OjqioaHB9OnTmT59+nvdIxMSEti8eTObNm2ioKCgyH6LYpGdnc0PP/zA9u3b0dDQYNasWXz33XdUqlRJbfeBqKgorKysSElJwd7eniVLliiqtGNjY+nUqRO5ubkcOnSoUEXr0aNHmTx5Mrm5uezcuZMvv/xS5Xoryty1KPLz87l06RK+vr74+Pjw9OlTjI2N6du3L3379qVr164V2l1GChBKSEhIVHDWrl3LsmXLGDJkCDt27Cjx3ClTpuDh4cHChQuZPXu2SAr/QtKqGkaNGsWpU6cYNGgQu3fvJjs7m169enHnzp1CjcDnz5+Pm5sb7du35+zZsyrXFhkZqRSIlG8OeHt7K222F0VERAROTk7o6OiI0htD0loxENO2deXKlaxevZrx48czYcIEUa3jSouktexJSUnBysqKyMhImjRpwpw5c7C0tKRdu3aKTYDU1FScnZ05cuQIurq6BAYGFmufpkr27dtHZGQka9euJT8/n0qVKtG8eXPq1q2LlpYWERERhISEkJ2djYaGBv379y+x+kGVC29Ja9kgt5F8O2Chq6tLTk4OBQUFfPHFF+zfv19xLCMjg8OHD7Np0ybCw8PR0dEhICBA5ZW8ubm59O3bl+vXryMIAs2bN6dnz560bNmSOnXqoK+vj7a2NtnZ2aSnp/PixQvu3buHn58fISEhyGQyOnXqxO+//y6KU8M/2eTLzMzk4sWL+Pv7s2LFirIXVwLOzs7s2bOn3AYI7927R9euXcnLy8PMzIyRI0fyySef0LZt20KOAL/88gtTp05FEAQGDhzI1KlT6dGjh2ibr6GhoYwdO5bg4GCl75eGhgaVK1dGS0uLnJwcMjMzKSgoUByXyWS0atWKPXv20KRJE5Xr3LdvH87OzuTl5Sl0ymQyqlevjpeXFzdu3FB8jq1ataJOnTpERkYSHByMTCaje/fuikpCMdi4cSOLFi2ioKBAoXf37t0MGjSo0LnOzs7s3r1b6d+l7gAhvOnduGDBAnbu3KkIEKxdu1Zt2o4fP87UqVPJyMhAEAQ0NDRo0KBBsffWiIgICgoKkMlk6Ovrs3Xr1kKVZ6qiLAIoYlmNVxStMTExWFtbk5iYiCAItGjRgoYNGyqcZYriyJEjPH78mMOHD/P06VP09PS4cOGCIslYlcybN4+tW7ciCAKamppYWFhgbm6OiYmJ4nrNyckhLS2N6OhogoODCQ4OJj8/H5lMxvTp01m+fLnKdb4Lf39/pkyZQkxMDObm5mzbto1OnTqp7T5w9epVRo4cSUJCAoIg8Omnn9KmTRuFa8vevXsRBAErKys+/fRTRTD7wYMHyGQy/u///o8tW7aIorWizF3fh5CQELy9vfH19SUoKAg9PT26deuGnZ0dvXv3LtbWtbwiBQglJCQkKjgdOnTg0aNH3Lhx452LUXn1mJmZGdevXxdJ4V9IWlXD1atXFVZGRkZGFBQUkJCQgL6+Pnfv3qV69epcvHiRJUuWEBQUBLzpBefk5KRybStXrlSyOiotMpmMdu3a4efnV4aqikbSWjEQK0D41VdfAW/sd+R9r6pUqcLHH39cYqWw3K5HTCStqsHV1ZUVK1bQqlUrvLy8FBbNRW0cTZ48GQ8PD8aOHcuGDRtE15qcnIy1tTXR0dGMHTuWb775hrp16yqdEx8fz5o1a9i2bRuWlpb4+vqqJdNV0lo2+Pn5ERYWpvgvPDycqKgoRcCiRYsWXL58Wen8wYMHA1C5cmW2bt0qWhZ+VlYWCxcuxN3dnezs7PeqypTJZOjq6jJu3DgWL16Mjo6OCErV10fon3LhwgW8vb355ptvRLE2/xCOHDnC9OnTef369TsDROvXr2fJkiWKn9URIPL29ubYsWNcunSpxP6XJiYmWFtbM2jQIPr27SuaPnjTb3D37t0EBwejoaGBubk5Tk5Oiv6NW7ZsYcmSJWRnZyvGCILAsGHDWL9+veg2mUFBQbi5uREQEEBiYiJ79uwp8u8PcODAAVxdXRU908vT9/LcuXM4OTkRGxur9uDlixcv2LRpEydPniQ6Ovqd59epU4cBAwYwffp0jI2NRVD4hop0b61IWh8+fIiTkxM3btwA3v09MTEx4fXr18hkMgwMDNi+fbuo9y1PT09cXV2VerQW57wgp1WrVsybN0+pNYa6SUlJYfbs2Rw5cgQdHR3F3EZd10xSUhLr169n3759pKSkACglWMgRBEHxs4mJCS4uLowZM0Y0nRVp7loaEhMT8fHxwcfHB39/f7KysrC0tMTe3p4vv/yy0NqhPCIFCCUkJCQqOPLm1AkJCUWW479Nbm4uNWrUEKURdVFIWlWHu7s7Li4uZGVlAW823Ddv3qxYdG/atIkFCxYAYGNjw/Hjx0XJxHdzc1OqmIiIiEAQBMXGRUkIgkDDhg1ZtWpVqSxTPhRJa8VArADhh2T9qmthKGlVDVZWVty/fx8vLy8lW56iNo5CQkLo2LEjDRo0UEswU56VPWPGDJYtW1biuYsXL2bDhg3MmzdP5T3xikLSqjpycnIIDw8nLCyM1NRURo4cqTjm5+fHzJkz6devH1OnTlXLZkVCQgLe3t5cvHiR0NBQoqKiyMjIIDs7Gx0dHapUqULdunUxMzOjc+fO2NnZiZ6BXZE2hisikZGR7Nmzh/Pnz/PkyRN+/vnnYjf7Lly4wE8//URgYKCi6kxdf5eMjAyioqJIT08nJycHbW1t9PX1qVu3LlWqVFGLpvclPj6es2fPEhcXR40aNbCxsSkXPT3T0tLQ0tJCV1e3xPMePHjA7du3efHiBXPmzBFJ3bt59eoVP/zwA0+ePAHAy8tLzYre2KK/697auHFjtWhbsWIFgiAwf/58tbx/aahIWuWEhIRw48YN4uPjS3Q06tSpE8bGxnTr1o2RI0dSrVo1EVX+RXh4OJcuXVJcr0XdW83MzLC2tlbbNfs+HD9+nFmzZvHq1atyMXfIz8/nypUr3Lp1i/DwcBISEsjIyKCgoIDKlStTvXp1TE1N6dixI+3bty+Vjb6qKO9z19KSnZ3N+fPn8fHx4fTp04wZM0Zt64LSIAUIJSQkJCo4DRs25NWrVwQGBr6zaXNwcDDW1tZUr15dsZgRE0mraklMTOTy5ctoaWlhaWmplEHu4+ODr68vNjY2DBw4EA0NDbVorEgbb5LW8olYAcJLly590Li3+/yIhaRVNcizrP+eKFLU9y07OxsjIyO0tbVJSEgQXauFhQURERE8ePAAExOTEs+NiYnhk08+wdTUVFFVLiaS1n9Ocb0OS6KgoEBtz34JiX9CSkoK9+7dIyoqSlGFLiEhISEhUR5IS0vj5cuXANSvX1/Nav5d/BvmrmJZI/9TVF86ICEhISGhUiwtLfnjjz9YunQpv/76a7EbRjKZjKVLlyIIAm3bthVZ5RskraqlRo0afPHFF0UekzdPVjfDhw8vF5lq74Ok9b+NOgJSH4qkVTXIg4IpKSnvrGKSV4+LbdcmR25/9z7VVvJ+X5GRkSrVVByS1n9Oo0aN6N27N/b29vTo0eO9Kpgq+gaLxH8XQ0NDpSpusUlLSyM8PJzIyEjS09PJzMxUVGXVqVMHU1NTPv74Y9F1OTg4oKenx5IlSyqMI0RBQQHPnz+nUaNGhY5du3aNgIAAoqOj0dbWpmnTpvTp0+e93DHUQXZ2Ns+ePSMtLY06deqIatf5Ll6+fElGRgaZmZmKiqy/9/pUN0lJSaSnp1O3bt0SLeblpKamAmBgYKBqaYWoSFolxOejjz5StCFQB4GBgejq6mJpaak2DaqiPM1dV61aVaa/r7xVFUoVhBISEhIVnPPnzzNgwAAEQcDGxoaFCxcWClRdv36dpUuXcuHCBQRBwNPTk86dO0ta/yVaJST+S6iigtDNzY3U1FSlifqqVasQBAEXF5cye5+yQNIqHg4ODly6dIkff/yRqVOnKl4vqoJw9+7dODs706FDB86cOSO6VjMzM+Lj4zl9+jQdOnQo8dyrV6/Sq1cvtVW9S1r/OW5ubvj6+vLnn3+ioaGBlZUV9vb29O3blzp16qj0vSXKJ69evUImk1G1alWl13Nzczl+/Dj37t1TBDK6d+9OmzZt1KIzKSmJx48f06lTJ6XX8/PzOX78eKEAkYODwzu/e6ogJSWFXbt2cfLkSe7evavUw6koLCwsGDx4MI6Ojujr64uiUf4s0tXVZdWqVaL2kSotubm5rF27lh07dlCnTh0uXLigOBYfH8/48eOVXpOjqamJo6MjP/744ztbPpQlT5484cCBAzx48ACZTMann36Ko6OjopJ81apVbNmyhbS0NMWYTz75hO+//77YZE1Vcu3aNU6dOsXFixcJDw8nPT290Dm6uro0bdoUGxsbBg0apLbE1sOHD7N69WpCQ0OBN3/j3r17M3/+fMzNzYsdZ2hoiIaGhqJSSwwqktaKRGZmJgEBAQqL0eKSL8zMzOjSpQvdunV7pxWxqggPD+fUqVNcuXKF0NBQkpKSyMjIQFNTkypVqlCjRg1MTU1p3bo1vXv3xsLCQnSN8mfBkCFD+Pnnn6lcubLoGkpLSkoKe/bsITAwkIyMDBo0aIC9vT0ODg4ljhs5ciSCIPDLL7+IpPQv5J/z+1Kc24e6+9YWhxQglJCQkPgXsHbtWkUVG7zJVqtbty6CIBAVFUVKSopiYbtkyRJmzZolaa2gWtu2bUtYWBiCICgWHe+aSBWFPKCpLuLi4ggKCqJnz55oa2sDbzK0Fy9eTEBAAAUFBYoFmLqzLyWt5QtVBAhr165NVlYWMTExigqw8mrbKmkVj8OHDzNhwgR0dXVZt26doifG3/8N4eHh2Nra8vLlS9atW8e4ceNE1zp+/Hh+++032rZti6enZ7GbA5mZmTg4OHDjxg369u2Lh4eHyEolrWVJamoqZ86cwcfHh7Nnz5Kamoq5uTl9+vTBzs6Ozz77TBQdEuohPz+f1atXs3fvXkW1q7GxMd9++y2Ojo7Exsbi4OBAWFgYoLxZ1adPH7Zt2yaa7VVKSgrz58/n8OHDtGjRQikY9PjxY0aOHKnYhJfPrd/W+r///U+0Kr3z58/j6OhIcnKyQouhoSEmJiZUqVIFbW1tsrKySE9PJyYmRhEkEgQBIyMj3N3d+fzzz1WuU/4sMjMz4/Hjx3Tt2pVNmzaVu4q7vLw8Bg8eTEBAADKZDEtLS86dOwdAeno63bt35/Hjx8hkMtq2bUuzZs3Q1dXl5s2b3Lp1C0EQRL2vHjhwgFmzZpGbm6t0LVarVg1PT098fX1ZunSp4nxdXV1FD3hBEFi0aBHOzs6iaI2NjWXixImK79O7Atnw1/eqZ8+ebN26VdQ+r0uXLmXdunVF6tTT02PPnj3FOt6IPX+sSForCgUFBaxZswY3NzfFZ1PSNSu/VqtWrYqzszMzZswQQybwZv08e/Zsjhw5gkwme+d3S661bdu2LF26VJRngJy3n+NNmjRhy5YthZJwyhPXrl1jxIgRJCYmKn2ugiDQoUMHPDw8iu2Nqc7v1r59+4iMjGTt2rXk5+dTqVIlmjdvTt26ddHS0iIiIoKQkBCys7PR0NCgf//+JTrLbN26VUT170YKEEpISEj8Szh37hwrVqzg+vXrhY4JgkDnzp1xcXEpF/ZuktYPp23btoSGhipNjD5kc0edi5bly5ezfv16CgoKePz4saJX4hdffMHFixeVFuOtW7fGz8+PSpXU44ouaS1/qCJAaG5uTmRkJMOGDcPGxgaAKVOmIAgCW7dufa8NFzkjRowoM11FIWkVl1GjRnHy5EkEQaBFixZ07NiRXbt2IQgCy5cvJzg4mJMnT5KZmYm1tTWenp5qscN5/PgxVlZW5ObmYmpqiouLC7a2tooN9ZSUFPz8/HB1deXRo0cIgoCPj49aNhAkraohPz+fS5cu4evri4+PD0+fPsXY2FhhMd61a1dF4ohExaegoIAhQ4bwxx9/FLqXCoLA2rVrOXv2LD4+PhgaGmJjY0PNmjUJDQ0lMDAQmUxG+/bt8fHxeS/LvH9Ceno6vXr1UlRj2dracvToUeBN/2xra2tiYmLQ0tLiiy++oFmzZujp6XHz5k1+//138vPzadeuHd7e3iqvInvw4AHdu3cnMzMTU1NTnJycsLW1LbGvVEREBH5+fmzbto2HDx+ir6+Pv78/pqamKtUq3yiNj49n6dKlbNmyBR0dHaZOncrs2bPfy3pYDDZs2MCiRYuoXLkyP/74IyNGjFBUA61atYqVK1dSs2ZN9uzZU8iJxcfHh3HjxpGZmcn//vc/hg0bplKtN2/exNbWlvz8fMzMzLC3t0dfX5/AwEDOnTuHhYUFz549Iycnh2XLljF8+HA++ugjIiMjWb9+Pbt370YQBM6ePavyCr2XL1/SuXNnoqKi0NLSwsHBAVtbWywsLDAxMUFfX18pmB0dHc29e/fw8/PDy8uLnJwcGjVqREBAgChJgwEBAfTr1w9BEBg7dizOzs4YGRlx+/Ztli5dqrBJDAgIKHKOL2ZgoCJprSgUFBTw5Zdfcu7cOWQyGcbGxnTr1g1zc3Pq1KlTKPkiOjqa+/fv4+/vT3R0NIIgYGdnx8GDB1WuNScnhx49ehAcHIyWlhaDBw+mY8eOaGtrc/fuXQ4cOEBaWhqzZs3C0tKS58+fc/PmTfz8/EhJSUFTU5OffvqJ8ePHq1wr/HW9ubm5MW/ePNLS0hgzZgwLFiwod9bCsbGxdOrUieTkZIyNjRk9erTiu3X48GGys7Np0aIF586dK7JqVJ3freTkZKytrYmOjmbs2LF888031K1bV+mc+Ph41qxZw7Zt27C0tMTX17fCzL2lAKGEhITEv4z4+HiCg4NJTk5GU1OTmjVr0rJly0KWQ+UBSWvpWbJkCbGxscBfWUcHDhz4oN8lr4YRk6NHjyqqa4yMjLh27RpVq1bl0qVL2Nvbo6enx8qVK9HS0mLBggW8evWKn376iYkTJ0pa/yVa/ymqCBCuXLlSYX35T1H1gkXSKi55eXksW7YMNzc3cnJyEARBKdgur8gZNmwYa9asEc1arih8fX1xdHQkPT1d8Znr6+sjCIKiwkUmk6GpqcnKlSuZNGmSpPVfpvVtQkJC8Pb2xtfXl6CgIPT09OjWrRt2dnb07t1b1KoRibJnz549zJo1C21tbb799lsGDRqkCGR8++235OTk8Pr1a0xNTTl58qTCGhHeWOQPHTqUly9f8vPPPzN69GiVal2yZAnr1q2jRo0abNu2DVtbW8Wx7777ji1bttC4cWN+++03mjZtqjT2zp07DBw4kOTkZFxdXVX+/Ro3bhxHjx6lZ8+eHDx4sFQbe3l5eQwfPpwzZ84wdOhQduzYoUKlhTdKr169ypQpUwgPD6d69epMnTqVCRMmqN0xokOHDjx69IgNGzYUskHt2LEjDx8+ZNeuXQwePLjI8Tt27ODbb7/FysoKb29vlWodO3Ysx44do2fPnnh4eCgFpGfPnq1IEJo3b16R/aOmTZvG/v37GTJkCDt37lSp1nd9d0riyZMnDB48mKdPnzJjxgylikhVMXz4cLy9vRk8eDC7d+9WOiavMvX396d169b4+/sXmjuKGRioSFpfv35dJr9H1baUbm5uzJ8/n8qVK7N27VqGDRv2Xgl1MpmMw4cP4+zszOvXr1m9ejUTJkxQqdZ169axZMkSatasyYkTJ2jZsqXS8YiICPr27cvLly+5dOkSjRs3Bt78LdatW8eaNWvQ1NTE29tbFIvst6+36Ohopk+fjp+fH4aGhsyePZsJEyaUm4SR+fPn4+bmRuPGjfnjjz+UKgWDg4MZMGAASUlJTJw4kZ9++qnQeHUGCOfNm8fWrVuZMWMGy5YtK/HcxYsXs2HDhmKfFeURKUAoISEhISEhIRp2dnb8+eefTJgwgdWrVytenzNnDtu3b2fKlCmKBtAeHh5MnjyZTp064evrK2n9l2j9p6giQCiTydi5cyfnz58nJSUFgEuXLiEIAlZWVqX6XV5eXmWmqygkreohISGBEydOcOvWLeLj48nPz6datWpYWFjg4OBAkyZN1KpPTlRUFGvXruXkyZMkJSUpHdPT08PW1pbZs2errf/Y20haxSMxMREfHx98fHzw9/cnKysLS0tL7O3t+fLLLwtlQJc1ZRGAEgQBd3f3fy7mHVQUrb179+bq1assXry4kMX9/v37mTZtmqJPT1FW9O7u7sycOVOUoEvr1q159uwZ7u7uDBgwoMhjhw8fplevXkWOl9s9t2nThvPnz6tUq7zv6PXr1z+oAvDRo0e0b9+eWrVq8fjxYxUo/IuiNkpzcnLYvn0769evJzExkSpVqjBkyBC+/vprtfWcMzIyIicnh6dPnxZKrKxVqxb/j737jquy/v8//rgghkKgKLh34ARNnIGkhqKAmprm+KYpblz0kcgydwLuNDE1cZSR5kiJoZKKQjlz4EZUhjIFWbI5vz/8nVMnhqKcc6De99ut2y3PdV2cp3jm9brer1deXh6xsbG8+eabpR6fmppKixYtMDY2JiYmRqVZ27RpQ0JCAmfOnCkxY+7KlSu8++67SJLEpUuXSn3fv3HjBu+88w6NGzfmxo0bKs3asWNHoqOjCQgIqPBnKkBxEWGLFi24cuVK5Qf8h7feeouUlBTCw8Np3759ie2JiYl06dKFzMxMNmzYwLhx45S2q7MwUJ2yVnQuWmn+PrpEVWxtbbl+/To+Pj6v1BVkz549zJgxg44dO5Y6r7QyybNu27aNESNGlLrP4cOHGTduHKNGjWLLli1K25YuXcqaNWt4//332bVrl0qzQumPtx9++IGlS5eSmJhI7dq1mTRpEh9//LHKP++9SOfOnbl//z5+fn6ltug9duwYI0aMQEtLi9OnT5d4HdZkgdDKyoqYmBhu3rypdNFVaeLj42nTpg3m5uZcvHhRTQlfjygQCoIgCEI1UpltNTTRsq9p06ZkZGSU+GAlv4I4MDBQ0bP/yZMntGzZklq1ahEdHS2y/kuyvi5VFAhLU53aA4msQmliYmJITk6msLAQExMTWrZsqfJWgq9KZFWfvLw8Tp48SVBQEEePHuXjjz9W+dXN5ubmJCUlKZ3ErEiLYVBfa/TqklX+vn/jxg0aNWqktC06OhorKyskSeLu3buYmZmVOD4uLo727dur5bOAqakpBQUFxMXFlVhlLS8eJSQklNpODJ63KG3UqBGGhoY8evRIpVnleRITE9HT06vw8Xl5eZiZmaGvr09iYqIKEv6lvPfT7OxsvvnmGzZt2kR6ejqSJNGkSRMGDRpEnz59sLGxUfmKIblWrVrx5MmTUguEzZo1Iz09vdzfd25uLvXq1aNGjRqKLiqqUrduXQoLC5VmJ8tlZGTQpEkTJEkiJSWl1Db9OTk51K9fH11dXZKTk1WatTo9VuGv321SUlKZK3O//vprFi5cSL169bhy5YrSY1Sdnx+rU9aFCxeyb98+xRzaVyW/kE9VGjRoQE5ODo8ePXql1Wzy9wEDAwMeP36sgoR/adSoEdnZ2aW+Z8llZmbSuHFjzMzMFPNz5eTFofr163Pnzh2VZoWyH2+5ubls3ryZr7/+mrS0NLS1tenbty9Dhw7FyclJbXN9/07+uvXw4cMy7/+jjz7iyJEj9O7dm8OHDytt0+T3SPlnmfJeF+Ty8/MxNTVV2+trZah+g2cEQRAE4T9MPr/rdchb4mmiQJidnQ2g1NosLS2N27dvo6enp3R1s/xK4qysLPWG/P9E1v82Dw+P136urVy5EhcXF5XPfxBZVcPY2BgtLS0SExOrzfyIv2vatClNmzYlPz+/yucXWdVHT0+PAQMGMGDAAED1JwXh+SzH4OBg5s+fz4MHD5AkCRcXF8Ws3KqkumSVt5UrbQ51/fr1Ff9fWnEQULT1kn9+UCUTExMSExPJzs4ucbLV0NCQ1NRUioqKyjxe/p5R0ULtq2jUqBEPHjzg3Llzitm5FXH+/HnFz9EkAwMDPDw8mD59Onv37mX37t1cu3YNHx8ffHx8eOONN2jdujWdOnVi06ZNKs1iZWXFyZMnOXjwIC4uLkrbOnXqRGhoKBcuXChznnt4eDiAWla+1KxZk4yMDB49elSiZeebb75Jp06dAMqc4Z2UlARQZrG7MpmYmJCQkMDDhw9p3bp1hY+XXxigrnEZxsbGPHnyhMTERJo0aVLqPjNmzGDHjh08fPiQRYsWKXVFUafqlHXp0qUsWLAAd3d3du7ciSRJHDp0qMp0tpDT19cnJyeHzMzMVyoQyt/z1PG5S/6eU973FXn74dI+Q8m/a6empqog3cvT19fHzc0NFxcXNm3axK5duzh+/DghISHMmjWLTp068e6772JtbU3Hjh3LfKxXJl1dXfLz88u9sG758uUcPXqU0NBQ/P39GTRokMpzvYzatWuTlJTE5cuXX9g69vLlywBVprXryxAFQkEQBEGoRmxsbEr9sFpQUMC5c+cUfzY2NqZJkyZoa2sTHR2tuMrKyMiIiRMnlvnFVtXq1q1LYmIiDx8+xMLCAkAxrLxr165KH/rlV4lr6oOVyFr55CtgX7Y47efnh7GxMY6OjorbPDw81HKi9vPPP3/tn+Ht7c3gwYNVXsgSWVWjadOmxMbGEhUVRdu2bVV6X5WlsLAQX19ffv31V27fvk1KSgoymYy0tDQiIyPZvn07U6dOpUWLFpqOKrJWMnkb6cpSmasKJUli4MCBWFhY0KVLF2QyGVOmTFH5SvBXUV2ympqaEh8fz40bN0qcqNLT03vhyep79+4BKM3/UZVu3brh7+/P7t27cXd3V9rWo0cPAgMDOX36dKntxgCOHz8OoJbn1+DBg1m/fj2urq7s3buXdu3avfSxN2/exNXVFUmSGDJkiApTvjwjIyMmT57M5MmTiYiIYNeuXRw7dozo6GiuX7/OjRs3VF4gnDZtGidOnGDBggXUr18fJycnxbaZM2dy6tQpFi5cSGBgYInCWmpqKvPnz0eSJLWcJG7Xrh1nz57lhx9+YPHixUrbJEkiNDS03OPlrftfpT1tRdnZ2bF3714+/fRTfvrppxIrHsuTl5eHu7s7kiTRu3dv1YX8m86dO3P8+HG2bt1a5vwuHR0d1q5dy9ChQ9m2bRu9e/dWeryoS3XKCs+LLitXruTQoUNkZGTQoEEDmjZtqpEsZenYsSOnTp1i3bp1eHt7V/j49evXA6illbu5uTmXL18mODi4zNmo8gsXSms1eeLEiTK3aYKRkRHz58/Hw8OD4OBgdu/ezfHjx7l06RJ//vknoJ42s/B8RfnVq1f57bffSrQcl2vWrBlz5sxh5cqVzJ07lx49elSJi7Ts7Oz4+eef+fzzz/H39y9zFX5OTg6ff/45kiSpZQZlZREFQkEQBEGoRkqbE1NYWMiwYcMA6NOnD5999hk9evRQ2ufq1ausWLGC4OBgrly5wsGDB9WS95+6d+/OkSNH8PLywtfXl7y8PDZs2IAkSYrVDHJbt24FeKWrYiuDyFr5pk+fjpaW1ksXCD08PNDS0uLhw4dKt1UX6ljtUFlE1pJmzZqFu7s7vr6+GrsyvCKioqIYNmwY0dHRSr8j+UUlWVlZbN68mV27drFt27ZS55Kpi8ha+Tw9PSu0OlfeTaCs21XRdrRVq1ZYW1tXi3ksVT1r9+7dOXToEAsWLMDf379EYWXKlCnlHv/1118jSRLW1taqjAk8LwIFBATg5eWFgYEB06ZNQ0tLC4BPPvmE4OBgvvzyS7p161biwo/79+8rCkRlnaitTPPmzePIkSPcv3+fXr160a9fP+zt7bG0tKRhw4YYGhqiq6tLXl4eWVlZPH78mIiICEJCQggJCaGwsBBzc3PmzZun8qwVZWlpyerVq4Hnv9cTJ05w6tQpld+vg4MDc+fOZf369YwdO5Zu3boxZMgQrK2tad++PW5ubqxbt44+ffowc+ZMOnToQH5+PufOncPHx4dHjx7RpEkT3NzcVJ515MiR/PHHH2zYsIHCwkJGjBhBs2bNXqoV38mTJ1m+fLnaCsTu7u4EBAQQGhpKt27dmDp1Kv369Sv38/3t27cJCQlh69atREdHY2RkxKeffqryrAAff/wxx44dY+PGjaSnpzN+/Hjatm1b4iR73759mTx5Mtu2bWPixIl4enpWymzYf2tWOT09PWxtbVU+U/ZVzZo1i1OnTrFlyxYSExOZO3euYkVuea5cucL69ev55Zdf0NLSYs6cOSrPOnLkSP788088PDxo3bo1HTp0UNoeHR2t6Ijy94tYAU6dOsUnn3yCJEllFsA0RUtLC0dHRxwdHUlOTubYsWOcOnWKkydPqrwlspyjoyNXrlzB3d2dBg0alFlAc3d359dff+XmzZsMHTqUQ4cOabxI+Omnn3L48GEuXbrEu+++i4eHB/b29or3h/T0dEJCQvD29ubOnTtIksTs2bM1mrkixAxCQRAEQajm1qxZw7JlyxgxYgTbtm0rd9/p06fj5+fHwoUL+eSTT9SU8C/nzp3DwcEBeN72qri4mOTkZAwNDbl27Rp16tThzJkzLFmyRHFSbsWKFcyYMUNkrYZZY2NjiYmJUfzZ0dERSZIIDAx8YZEnJiaGGTNmoKenp/KZM6qirnmJlUFkLZ2npyerVq1i0qRJTJ48WS2rAl5Feno6NjY2xMbG0qpVK9zd3bG2tqZr166KWR0ZGRm4ubmxf/9+9PX1CQ8PL9FCTWStvll3795NbGwsa9asoaioiDfeeIO2bdvSuHFjdHR0iImJ4datW+Tl5aGlpcWQIUPKXXGyefNmleT89NNP2bp1K2fPnq3yrzdVOeuff/5Jv379KCoqomHDhjg7O9OsWTNcXV3LPObx48dERUWxa9cufv75ZyRJ4uDBg/Tt21flebdu3YqHhwcymYzGjRvj5ORE586dadasGQEBAWzYsAEzMzMmTpyoVCD68ccfyczMxMrKit9++00t7eWePHmCq6srQUFBQPlt5uTkn2mcnZ3ZsGGDyle4Q/Wb6evn58fSpUt5/PjxS1/MIJPJ6NatGzt27FBLi9Hi4mLGjBlDUFCQUpvB8lbWjBgxglu3bhEXF4dMJqNDhw6EhIRUaEXfq/rjjz/4+OOPSUhIUOTV0dGhQYMGGBoaoqOjQ35+PllZWSQkJFBQUAA8/702aNCAXbt2qXWFy7x589i2bZvS73b79u2KC13lCgsLGTNmDEePHkWSJN58800yMjLU+nivTlnlli9fzqpVqzh37lyVe88C2LRpE19++SXFxcUA1KlThw4dOihmzP7z4ovr16/z5MkTZDIZ2trarFixgmnTpqk8Z0FBAQMHDuTChQvo6uri7OzM22+/TV5eHnfu3OHIkSPk5eVRv359wsPDFSM+hg0bpujg07ZtW44fP65oN6pKlfFecOPGDdq3b195ocqQmZnJu+++S1RUFJIkYWFhQbt27Zg1a1aJC5YiIyNxcHAgNTUVIyMjhg8fjq+vr0bf94KDg3FxcSErK0vx2mBoaIgkSWRmZgIoHq+enp5MnTpVIzlfhSgQCoIgCEI11717d+7cucOlS5deOG/gwYMHdOrUCQsLCy5cuKCmhMp27tyJh4cHubm5wPNWl998843iC9fGjRtZsGAB8LyVw6FDhzTWElVkfT2enp6v1EZGTt4iNSQkpBJTqY8ouqmGurJ++OGHAFy7do34+Hjg+fOqVq1a5c7OuHbtmkpzlcbb25sVK1bQsWNHAgICFCckSjtpMG3aNPz8/JgwYYKiZZPIWv2zpqamYmtry+PHj5kwYQL/+9//SpxQT0pKYvXq1WzZsgVra2uCg4PVPkfx6tWrhIeHM3r0aLXNvnpVVT3r/v37mTNnjmKm8ItOmjVq1Ijs7GxFMWvevHl8+eWX6ogKwJkzZ/jyyy8Vs3leVCSSr2YdPnw469atw8jISB0xFSIiIjh06BBhYWFERkaWOk/KxMQECwsLbG1tGTp0aImVJqpU3QqEAPn5+QQFBXH06FGuXLlCVFSU4nOrnK6uLi1atKBnz54MGTJELQXsv5PJZPj6+rJ7926uX79OYWFhubNaGzZsSHZ2Ntra2gwbNoxVq1ap9fXi2bNn7Ny5k19++YWLFy+WO8/zjTfeoEuXLgwdOpTx48erpYj5T7/88gvffPMNf/75J0VFRezYsaNE0Q2gqKgIb29vNm3a9NKvcf/lrPC8sPXs2TOMjIxee963qly+fJlVq1Zx/Phx8vPzlbZJklTiAlI9PT369+/PvHnzXmrFYWV5+vQpU6dOVbQN/ucs3FatWrFnzx6lEQQ2NjZERkYyduxYvvrqqzJbUFa26vZekJCQwKxZszh27Bjw/Hfr6+tb6nPr5s2bjB07lvv37yseH5r+u8bFxbFmzRoOHz7MkydPlLbVqFEDe3t7PvnkE7W0w61MokAoCIIgCNVcvXr1yMvLIzk5WTEwuywFBQXUrVsXfX19EhMT1ZSwpJSUFP744w90dHSwtrZWahkRFBREcHAwdnZ2DB06VNGGSlNE1lfn4+OjtAolJiYGSZJeagi6JEk0b94cLy+vCs0AqkpE0U011JXV2Ni4wsdo6kurjY0NN27cICAgABsbG8XtpZ00uHXrFj169KBZs2YaKWaKrKrx2WefsXnzZmbPnl3mzCS5xYsXs379ej777DOVtBIV1OfJkyccOHCAS5cukZSUxKFDh8rct0GDBgD06tWL6dOn06dPH3XFVHL58mVFgejevXskJyfz7NkzioqKMDAwwMTEBHNzc3r27MngwYOrzMrtnJwcsrOzycvLQ09PDwMDA40UWOTkHRqq2qyxisrMzFT8+9esWRMjIyONf56WKygoIDU1lXr16pW5z/r162nSpAl2dnYab4GXm5vLgwcPiI2NLfFYbdKkCS1btkRPT0+jGeWysrKIjo6mfv365a64zcnJ4dSpU1y9epVHjx6xceNGNaZ8rjplrS6ePXvGuXPniIyMJC4ujqysLPLz89HV1cXQ0JDGjRtjYWFBt27d1FZoK83Zs2f59ddfiYyMJD8/nwYNGtC7d2+GDh1a4rzL+fPn6dChg9rzTps2DUmSVNb5QVUiIyMJDQ3l/v37jBgxgrfffrvU/QoKCti/fz+BgYGK59Y/C3OaEhMTQ3JyMoWFhZiYmNCyZctyLyKtykSBUBAEQRCquebNm/P06VPCw8Nf2BoiIiICW1tb6tSpw/3799WUUBCeq25XOL4uUXRTDXVlDQsLe6XjbG1tKznJizVs2JBnz56VuFCktOdcXl4eZmZm6Orqqm3miMiqelZWVsTExHDz5k0aNmxY7r7x8fG0adMGc3Nzlc/YK2vWYVX0b88aHx9PvXr1qkzxRRAEQRAEobqTF7erM830wBIEQRAEodJYW1vz22+/sXTpUn766acyTxjJZDKWLl2KJEl06dJFzSkFAUaPHl1tTr4KgiYKfa9KXrxKT09XzEIpi3z1uKZWvoisqiFvg/uinIBiBURsbKxKMwG0aNGCAQMG4OjoyHvvvYeBgYHK7/NVVbesDg4OODk5vXRW+QpCoWJu3bpFZGQkMTExZGdnk5OTo1jl0qhRIywsLLC0tFR7LisrK2rUqIGnp6fa23D+VyQmJvLHH3+QnZ1Ns2bN6Nq16wtX4AUGBgLP525rQmpqqmIF4bNnzxQrCBs3boyZmZlGMlVEfn4+Fy9eJCEhgbp169K1a1eNrtQtLCzk2rVrisfAy6zYvX79OoBaWw6/rPnz5yNJEitWrNB0lBLkK16rgh9//JEaNWrw/vvvV/nvrtUp679BYWEhvr6+/Prrr9y+fZuUlBRkMhlpaWlERkayfft2pk6dSosWLTQdtUJEgVAQBEEQqrmZM2cSEhLC0aNHGTJkCAsXLixRALxw4QJLly7l9OnTSJLErFmzVJ6rS5cu3Lt3D0mSSEtLA8DZ2bnCP0eSJPz9/Ss7nhKRVT2+/fZbtd6fILwsHx8fMjIylNotenl5IUkSHh4eGkz2ciwtLQkLC2Pv3r24urqWu698pqemVouKrKpRu3ZtkpKSuHz5Mt27dy93X/kMOHUUwD799FOCg4OZOHEiWlpa2NjY4OTkxMCBA2nUqJHK778iRFbNOXbsGMHBwYqZdCYmJrz99tsMHz78hfO1VeH+/fts2LABf3//l2plZmJiwvvvv8/cuXPV1vIzOjpaMaPRzc2N+fPnv3DUgPBy8vLycHd354cffqC4uFhxu6mpKV988QUff/xxmceOHj0aLS0txWd0VSsuLubgwYMcOXKEM2fOlHu/RkZG2NnZMXz4cI0UE+Li4ti5cyfXr19HkiSsrKyYNGmSojXroUOH+PTTT5VW4desWRM3Nzfc3d3VmhVg9erVfP3112RmZipus7S0ZNGiRdjb25d5nI2NjVofAxXh4+Oj8QLho0ePCAgIUMx3lRe05fP9atSoobj4ws7OjsGDB7+wM0Jlmz59OpIk8d1337F9+3bq16+v1vuviL9n9fX1LbclclVx//59bt68iUwmo127dkrv83fu3GHTpk1ERESQlZVFw4YNsbe3Z8KECRgaGmowNURFRTFs2DCio6OV5mXKX0uzsrLYvHkzu3btYtu2ba90jkZTRItRQRAEQfgXWLNmjWJ1IDz/Ati4cWMkSSIuLo709HTFh5glS5Ywd+5clWfq0qULkZGRSm3YqupML5FVvRITE7l48SL9+vVTtOPIzMxk8eLFhIaGUlxcjIODA/Pnz8fIyEgjGSuDaNupGqrIWr9+fXJzc4mPj1dcqV6dWuLu27ePyZMno6+vz9q1axk7dixQ8u8QFRWFvb09aWlprF27lokTJ4qs/5KskyZN4ueff6ZLly74+/uXOQMnJycHZ2dnLl26xMCBA/Hz81NLvoyMDI4dO0ZQUBDHjx8nIyMDS0tLxYq9smbPaILIWvnMzc3R0tLizp07SrfHx8czfvx4zp8/D1DihJuWlhYTJ05kxYoVamvf9eOPP+Lm5kZeXh4ymQw9PT0sLCxo2LAhBgYG6OrqkpeXR2ZmJvHx8YrZVJIkUaNGDTZt2sSwYcNUnlP+OmRnZ0doaCht27Zl48aNdO3aVeX3/W9WXFzM0KFDCQ0NRSaT0bRpU0xNTbl37x7p6elIkoSbmxuLFi0q9Xh1fna4ceMG48eP5969e0rPHQMDA8VjNTc3V7HyVU6SJNq1a8euXbvUNuPzl19+Ydq0aeTm5iqySpJEgwYN8Pf359atW4wbN47i4mJMTExo2LAhjx49Ii0tDUmS+Oijj9Q602/q1Kns3btX8RpgZGSkKFxqa2uzatUqXFxcSj22Kn9+1GS27OxsPDw8+OmnnygsLFR6zJZFkiR0dHQYN24cX331Ffr6+mpI+tfvCZ5fgOXt7c3IkSPVct8VVZ2yPnr0iKlTp5YY4/D++++zZcsWrly5wrBhw5QKxvD8cdCwYUP27dunsZW56enp2NjYEBsbS6tWrXB3d8fa2pquXbsqnlMZGRm4ubmxf/9+9PX1CQ8P56233tJI3ooSBUJBEARB+Jc4ceIEK1as4MKFCyW2SZJEr1698PDwUFvbvCVLlpCQkACgGJq9Z8+eV/pZ8pOyqiKyqs/y5ctZt24dxcXF3L17V3HV8KBBgzhz5ozSSYNOnToREhLCG29Uz6YX//Wim6qoIqulpSWxsbGMGjUKOzs74K8rcjdv3vxSJzHkxowZU2m5KmLcuHEcPnxYceKvR48ebN++HUmSWL58ORERERw+fJicnBxsbW3x9/fX2CwykbXy3b17FxsbGwoKCjA3N8fDwwN7e3tq1aoFPD+xERISgre3N3fu3EGSJIKCgujZs6fasxYVFREWFkZwcDBBQUE8ePCABg0aMHDgQAYOHEjv3r2rzCwXkbVylHZSOisriz59+hAZGQnAe++9p5iTnZGRwdmzZwkKCqKoqAgnJ6dX/qxTEWfPnsXR0ZGioiJ69erF3LlzsbOzK/f3lp+fz+nTp9m4cSOnTp1CR0eH4OBglbfz//vvdOvWrSxevJhnz54xYsQIFi1aROPGjVV6//9Wu3btYvbs2ejp6bF582aGDx8OPL+4wtvbm3Xr1iFJEnv27MHJyanE8eoqwMTGxtKrVy/S0tIwMTFh/Pjx2NvbY2lpWeqFg2lpady4cYOQkBC+//57UlJSMDU1JSwsTOWro27cuEHv3r3Jz8+nQ4cODBgwAG1tbYKDg7l69Spt2rQhNTWVtLQ01q9fz9ixY5EkCZlMxq5du/jf//5HUVER+/fvL3flXmU5fPgw48aNQ0tLi4ULFzJjxgz09PSIj49nwYIF7N+/H21tbQIDA+nRo0eJ49VZhGvZsmWF9n/y5AmSJGFiYqK4TZIkoqKiKjuaktzcXPr378+1a9eQyWR06dIFe3t7rKysaNiwIYaGhujo6ChdfHH9+nV+++03Lly4gCRJWFtbExQUpJb3Mfm/4a+//sqMGTOIiYnhvffew8vLS21F9ZdVXbI+ffoUOzs7YmJikMlkmJmZYWhoyMOHD5HJZLi4uHD27FmuX7+OtbU1I0eOxNTUlMjISHbs2EFCQgINGzYkPDxc6fGrLt7e3qxYsYKOHTsSEBDAm2++CZT+fJ82bRp+fn5MmDCB9evXqz3rqxAFQkEQBEH4l0lKSiIiIoLU1FS0tbUxNTWlQ4cO1K5dW9PRhP+4AwcOKFbWmJmZcf78eWrXrk1YWBhOTk6KWTo6OjosWLCAp0+fsnLlSqZMmaLh5K/mv150UxVVZPX09FS0FH1dmrpivLCwkGXLluHj46NYzfL3grtMJkOSJEaNGsXq1as12qZHZFWN4OBgXFxcyMrKUjyWDQ0NkSRJ0SJNJpOhra2Np6cnU6dO1VjWv7t16xaBgYEEBwdz8eJFatSoQZ8+fXB0dMTBweGl5iqqi8j6ako7gebl5YWnpyfGxsb4+flhY2NT4rirV68ydOhQUlNT2bZtGyNGjFBpzg8//JDg4GDGjBmjuAirIqZPn86PP/6Ik5MTP/74owoS/uWfv9MHDx7g6upKeHg4urq6jBkzhtmzZ2ukRes/ffnll6/9MyRJYunSpZWQpnwDBgzg7NmzzJ8/v9QW41988QXffPMNZmZm/Pnnn4qTxHLqKg7Nnj2bXbt2YW1tzc8//6yYLfsynj59yrBhw/jzzz+ZMGEC69atU2HSv1a4Ozk58f3336OtrQ08X635f//3fwQEBChGYCxbtqzE8fPnz8fHx0ctzyuAIUOGEBoayuTJk1m1alWJ7S4uLuzfv58WLVpw/vz5EgUrdRYImzZtSnp6+mv9DHVklX/Orlu3Lrt27arQBct//PEH48aNIzk5mS+++EIt7Wb//m+YnZ3NggUL2LFjB2+88QYfffQRbm5uamsn/SLVJevy5ctZtWoVDRo0wNfXl3feeQeAx48f8+GHHxIREQFA37592b9/v9LFdunp6Tg4OHD79m0+/fRTPv/8c7Xnt7Gx4caNGwQEBCh9Xint+X7r1i169OhBs2bNuHbtmtqzvgpRIBQEQRAEQSUq8wucqlfkiKzq4ejoyO+//17iC7e7uztbt25l+vTpeHl5AeDn58e0adPo2bMnwcHBas1ZWf7rRTdVUUVWmUzGd999x8mTJxUnWsLCwpAkqdST1uUJCAiotFyvIjk5mV9++YXLly+TlJREUVERJiYmWFlZ4ezsXCVOFsuJrJUvLi6ONWvWcPjw4RKz02rUqIG9vT2ffPIJnTt31lDC8qWkpBAUFERQUBCnTp0iNzcXa2trnJyc+OCDD6rUqiiR9eWVdgKtR48e3L59m3Xr1jFhwoQyj92zZw8zZszg3Xff5ciRIyrN2apVK548eUJERARNmjSp8PExMTFYWlpSt25dla/IKasI4e/vz/Lly7l9+zZaWlq8++67jB8/ngEDBihaaKubqakpBQUFr3y8/EIMdRVcMjIyuHLlCs2bNy+xPT8/n65duxIdHc3cuXNZvHix0nZ1FYfatWvH48ePOXXqFJ06darw8ZcvX6Z37940btyYGzduVH7Av2ndujWJiYmEh4fTvn17pW03b96kZ8+eSJLEhQsXSl3xdOfOHbp164aZmZlixbEqNW/enKdPn5aZJzMzk86dO5OcnMySJUuYM2eO0nZ1FggTEhKYNm0aJ0+eRJIkJk6cWGaLY5lMhrOzs2K12d+pusNQ165diYyMxM/Pj4EDB1b4+KCgIEaNGkXr1q0VLalVqbR/w9DQUL744gsiIiLQ0dFh2LBhuLi4vHDus6pVl6w9e/bk1q1b7Ny5k/fff19pm/zfV5Ikjh49WmrOY8eOMWLECMV8cHVr2LAhz549Izk5WWneb2m//7y8PMzMzNDV1VWaqVqViQKhIAiCIAgq8fd++K9KXScERFb1kJ90uXnzptKweflJwsDAQMXVhE+ePKFly5bUqlWL6OhoteasLP/1opuqqCtrVZ4hIwgvIyYmhuTkZAoLCzExMaFly5aKlRvVQV5eHidPniQoKIijR4/y8ccf89lnn2k6VqlE1vKV9noqn/0aFRVV7uqn1NRUWrRooZbPA6XNo62InJwc6tevT82aNYmPj1dBwr+U9x4lk8n46aef8PLy4uHDh4r5iO+99x59+vTBzs5Ora3nMjIy8PPzw8vLi9TUVCRJwtHRscIztF9lVWdFyYuZ/zwJ/He//vorY8eORV9fn4sXLyoVk9X12cHMzIz8/HwSExPR09Or8PHyE9j6+vokJiaqIOFf6tatS2FhIQkJCSVmyMmfM5IklbodnrenrFevHjo6OqSkpKg069/zlvcY2L17N7NmzcLY2JjLly8rvYZp4vPj1q1bWbRoETk5OXzwwQesWbOm1OeXpj7b1qtXj7y8vNd+ba1Ro4Zi1IYqlfd7OnDgACtWrODevXtIkoS5uTnDhg1j8ODBJQrg6lBdsjZo0ICcnBwePHhQorNVYmIiFhYWSJJETEwMRkZGJY6XnxswMDDg8ePH6oqt0KxZM9LT07l3755SB4bSfv/yi4WMjY2JiYlRe9ZXUT0HugiCIAiCUOXZ2NiUWsgqKCjg3Llzij8bGxvTpEkTtLW1iY6OVny4MjIyYuLEiWqZPyeyqkd2djaA0ofqtLQ0bt++jZ6entK8HnnLpqysLPWGFIT/z8PD47WL8StXrsTFxaVCrb9ehbGxMVpaWiQmJlaZeWhlEVnVp2nTpjRt2pT8/PxqmV9PT48BAwYwYMAAgNduo6ZKImvF6ejokJubW6JF4z/JCwbPnj1TeabmzZtz+/ZtQkJCGDRoUIWPP3HihOLnaJIkSYwePZpRo0Zx7Ngxdu/ezdGjR/H391esHDIyMqJjx474+/urPI+RkRFTp06la9eu9OnTB4CFCxdWyYuS6tWrR1xcHHfu3KFDhw6l7uPs7My7775LaGgorq6uKl/ZWpp69eoRGxurmNdVUTdv3gSeFxpVrXbt2iQnJxMdHU3r1q2Vtv395Pnjx49LnaknL7a/6LWistStW5eEhASio6N56623St3no48+4rvvvuPatWvMmzePHTt2qCVbWaZMmUKfPn2YMmUKP//8M7///jvffPMNffv21WguuTfffJO8vDwSExNf6fVRvgpLk23c5YYPH87QoUPx8/Nj27ZtXL58GW9vb7y9vTE1NaVXr15YW1vTqVOnCnch+TdnLS4uBp7PS/6nv39PKq04CChajpZ2vDrIVy7u3bsXV1fXcvcNCQkBqJLvcWURBUJBEARBEFQiMDCwxG2FhYWKtid9+vThs88+KzHc/erVq6xYsYLg4GCuXLnCwYMHRdZqmvWf6tatS2JiIg8fPsTCwgJ4fjJNJpPRtWtXpRPYjx49AsDAwEDtOeGvVq4v24bVz88PY2NjHB0dFbd5eHhgamqqknx/J7KqRmXMt/D29mbw4MEqLxA2bdqU2NhYoqKiaNu2rUrv63WJrKpVWFiIr68vv/76K7dv3yYlJQWZTEZaWhqRkZFs376dqVOn0qJFC41llLeSriyqXP0msqqOtbU1p06dIiIiotwCx9WrV4HnBRFVGzFiBEuXLmXmzJno6enRv3//lz72+PHjuLq6IkkSI0eOVGHKlydJEg4ODjg4OJCSkoKfnx/BwcGcP3+e9PR0zpw5o9Y8nTt3xtLSkuvXr6v1fivinXfeYe/evSxevJi9e/eWuep67dq12Nracvr0aZYsWcKiRYvUmrNfv35s376duXPncuDAgQoV+pKTk5kzZ47i8aFqPXv25MiRI3h7e+Pr66u0zdvbW/H/R44cYe7cuSWOP3ToEABWVlYqzSnXtWtX/P39Wb16Nd9++22p+0iSxPr167G3t+fQoUO88847TJ48WS35ymJubk5ISAgrV65k9erViraSy5cv11h7Ybnu3bsTEBDA0qVLSzwGXsbSpUuRJImePXuqIF3FaWlpMXbsWMaOHcvNmzfZuXMn+/btIykpiQMHDnDw4EEkSSItLU3TUatM1kaNGnH//n1+//13Bg8erLTtjTfe4OzZs+UeL5/lV79+fZVlLM+4ceM4c+YMS5cupVatWowdO7bU/aKioli2bJliPnl1IVqMCoIgCIKgNmvWrGHZsmWMGDGCbdu2lbvv9OnT8fPzY+HChXzyySdqSvgXkbXyjRs3jiNHjjBs2DB8fX3Jy8ujf//+XL16leXLlzNz5kzFvvPnz8fHx4du3bpx/PhxteaEv1YOveyXpaZNm6KlpcXDhw9VG6wUImvVpa52qFu3bsXd3Z0pU6YozfesikRW1YmKimLYsGFER0cjk/31NV/e+kg+c6pmzZps27YNZ2dnjeSsaKtseVvssm5XZas0kbVysy1YsIA2bdrQtm1boqKiGDFiBO+88w5HjhwptZVfdnY2gwcP5tKlS4wePVrlLSYLCgoYOHAgFy5cQJIk2rZtS79+/ejQoQONGjXC0NAQXV1d8vLyyMrK4tGjR1y/fp2QkBBu3bqFTCajZ8+e/Prrryrv1PA6rQJzcnI4c+YMp06dYsWKFZUfrhxubm7s2LGDs2fPVsnVFdevX6d3794UFhZiYWHB2LFjadOmDV26dClxsc8PP/ygKAoPHToUV1dX3nvvPbW0cExMTOSdd97hyZMnvPnmm4wePRp7e3ssLS0VLTvliouLSUhIICIigpCQEPbu3Ut6ejr16tUjPDxc5RddXbp0iX79+lFcXEz37t1xcnJCkiQCAgI4e/YszZo14+nTpxQWFrJ3716leXinTp1i9OjR5OTksHXrVrUU38PDw3F0dESSJHr37s348eNp27YtzZo1K1FoW7VqFcuXL0dLS4s5c+YwY8YMzM3NNd6i/tKlS0yZMoV79+7RqlUrtmzZQteuXTXWYvTSpUs4ODhQWFhIly5dmDNnDn369Cl3RWBWVhYnTpxgw4YNXLx4ER0dHY4fP/5KMzcr6lV+T/JuPidPnuTEiRNcvXqV1NRU1YX8/6pL1k8//ZQtW7bQoEEDDh48SLt27V762Pz8fPr168fVq1f56KOP2LhxowqTlm3cuHEcPnwYSZJo164dPXr0YPv27UiSxPLly4mIiODw4cPk5ORga2uLv7+/YuVjVScKhIIgCIIgqE337t25c+cOly5dolWrVuXu++DBAzp16oSFhQUXLlxQU8K/iKyV79y5c4orlc3MzCguLiY5ORlDQ0OuXbtGnTp1OHPmDEuWLOHixYsArFixghkzZqg8W2xsrFKbI/mJgcDAQKUT7aWJiYlhxowZ6OnpqWUuhshafahztqOnpyerVq1i0qRJTJ48Wa3zpSpKZK186enp2NjYEBsbS6tWrXB3d8fa2pquXbsqThxlZGTg5ubG/v370dfXJzw8vMz2aaq0e/duYmNjWbNmDUVFRbzxxhu0bduWxo0bo6OjQ0xMDLdu3SIvLw8tLS2GDBlS7uoHVRaNRNbKIZ+F9feihb6+Pvn5+RQXFzNo0CC+//57xbbs7Gz27dvHxo0biYqKQk9Pj9DQULWs5M3NzWXhwoXs3LmTvLy8lyq6ymQy9PX1mThxIosXL36lmXAVVV3n5J4+fZrAwED+97//qaUbwKvYv38/s2bN4tmzZ4p/f19fX0W3jr9bt24dS5YsUfxZnXO+IyMjmTBhAhEREUqPUy0tLWrWrImOjg75+fnk5OQo2vvJM3bs2JEdO3a88HtDZdm9ezdubm4UFhYqsspkMurUqUNAQACXLl1SFFs7duxIo0aNiI2NJSIiAplMRt++fRUrCdVhw4YNLFq0iOLi4hc+Btzc3PD19VX6e1WF52Zubi4LFizgu+++Q0tLi7lz57JmzRqNZTt06BCurq5kZ2cjSRJaWlo0a9aszIsvYmJiKC4uRiaTYWhoyObNm0usPFOVynh9TU9Pr/Cc1VdRXbLGx8dja2tLSkqKosDWvHlzRXeZ0uzfv5+7d++yb98+Hjx4QI0aNTh9+rSiE5G6FRYWsmzZMnx8fMjPz0eSJMX3Wfn/y1cOrl69ukq0xH1ZokAoCIIgCILayAeUlzf0Xa6goIC6deuir69PYmKimhL+RWRVjZ07d+Lh4UFubi7wvIXoN998o/jCvXHjRhYsWACAnZ0dhw4dUsu8RE9PT6U2RxUlb5MqnzmgSiJr9aGuAuGHH34IPG+/I5/VY2BgQK1atcpsjybfX91EVtXw9vZmxYoVdOzYkYCAAMWsptJOHE2bNg0/Pz8mTJjA+vXr1Z41NTUVW1tbHj9+zIQJE/jf//5H48aNlfZJSkpi9erVbNmyBWtra4KDgzUyR1FkrRwhISHcu3dP8V9UVBRxcXGKokW7du34448/lPYfPnw4ADVr1mTz5s28//77Ks/5d8nJyQQGBnLmzBkiIyOJi4sjOzubvLw89PT0MDAwoHHjxlhYWNCrVy8cHR2VZiyrWnUtEFYXsbGx7Nixg5MnT3L//n2+/vrrMh+Dp0+fZuXKlYSHhysKSur8dwkMDOTgwYOEhYUp3qtK07BhQ2xtbRk2bBgDBw5UWz65O3fu4OvrS0REBFpaWlhaWjJjxgyaNGkCwKZNm1iyZAl5eXmKY+Qn29etW6f2NpkXL17Ex8eH0NBQUlJS2LFjR6kFQoA9e/bg7e1NdHQ0QJV6bp44cYIZM2aQkJCg8eLlo0eP2LhxI4cPH+bx48cv3L9Ro0a8//77zJo1iwYNGqgh4XPV6fW1OmW9ffs2M2bM4NKlS8CLnycNGzbk2bNnyGQyjIyM2Lp1q0Zeu/4pOTmZX375hcuXL5OUlERRUREmJiZYWVnh7OystgsvKpMoEAqCIAiCoDbNmzfn6dOnhIeH0759+3L3jYiIwNbWljp16nD//n01JfyLyKo6KSkp/PHHH+jo6GBtba10BXlQUBDBwcHY2dkxdOhQtbXl8PHxUVotERMTgyRJipMW5ZEkiebNm+Pl5VWhdimvSmStPtRVIHyVq341dTJBZFUNGxsbbty4QUBAADY2NorbSztxdOvWLXr06EGzZs00Usz87LPP2Lx5M7Nnz2bZsmXl7rt48WLWr1/PZ599pvKZeKURWVUnPz+fqKgo7t27R0ZGhtI8n5CQEObMmcPgwYNxdXUtUegUhKooPT2d69evExcXp7jARN2ys7OJi4sjKyuL/Px8dHV1MTQ0pHHjxhqb610RSUlJHD9+nMTEROrWrYudnR3NmzfXdCwyMzPR0dFBX1+/3P1u3rzJlStXePToEe7u7mpK92JPnz7lyy+/VHz3CwgI0HCi523RX3TxRcuWLTWSbcWKFUiSxPz58zVy/xVRnbLK3bp1i0uXLpGUlFTuyJOePXvSoEED+vTpw9ixYzExMVFjyv8WUSAUBEEQBEFthg8fzm+//YaDgwM//fRTmW2bZDIZI0eO5Pjx4/Tv3599+/apOanI+l9Xna7GFFmrLnUVCMPCwl7puL/P+VEXkVU15FdZ/3MleWnPuby8PMzMzNDV1SU5OVntWa2srIiJieHmzZs0bNiw3H3j4+Np06YN5ubmitbT6iSyvr6yZh2Wp7i4uNrM7REEQRAE4d/N2NgYLS0tEhMTNdIlQtVU369JEARBEATh/5s5cyYhISEcPXqUIUOGsHDhQrp06aK0z4ULF1i6dCmnT59GkiRmzZolsv6LslYXo0ePrvAJTU0RWQVNFKRelciqGvKiYHp6+gvbHMrbS6u7XZucvAXey7RjrFOnDvC83Z8miKyvr0WLFjg4OODk5MR77733UquYRHHw3+vp06fIZDJq166tdHtBQQGHDh3i+vXrZGZm0qhRI/r27Uvnzp01kvPJkyfcvXuXnj17Kt1eVFTEoUOHCA0N5fHjx+jq6vLWW2/h7OxM9+7dNZJVLjMzk6ioKGJjY8nKyiInJ0exIqtRo0aYm5tTq1YtjWRzdnamRo0aLFmypNp0hSguLiY6OpoWLVqU2Hb+/PkSj4EBAwa8VIcMTcjLy+Phw4eK55Y623W+SFpaGtnZ2eTk5ChWvMrfo6qKJ0+ekJWVRePGjcttMS+XkZEBgJGRkaqjlVCdslYnTZs2JTY2lqioKLXMQ1Y3sYJQEARBEAS1WrNmDUuXLlUUCYyMjGjcuDGSJBEXF0d6erpi2POSJUuYO3euyFoNs3bp0oV79+4hSRJpaWnA85MDFSVJEv7+/pUdTxDUQhUrCH18fMjIyFBqC+jl5YUkSXh4eFTa/VQGkVV9nJ2dCQsL46uvvsLV1VVxe2krCH19fXFzc6N79+4cO3ZM7VktLCxISkri6NGjLzyhfu7cOfr376+xttgi6+vz8fEhODiY33//HS0tLWxsbHBycmLgwIE0atRIpfctVA1FRUWsWrWKXbt2KQrZDRo0YN68ebi4uJCQkICzszP37t0DlFedDhgwgC1btrxSy+dXkZ6ezvz589m3bx/t2rXj9OnTim13795l7NixREZGKnICSlm//fZbtRbh0tPT2b59O4cPH+batWuKTGWxsrJi+PDhuLi4YGhoqKaUf70X6evr4+Xlxccff6y2+66ogoIC1qxZw7Zt22jUqJHSYyApKYlJkyYp3Sanra2Ni4sLX3311Qtnwlem+/fvs2fPHm7evIlMJqN9+/a4uLgoVpJ7eXmxadMmMjMzFce0adOGL774gkGDBqktp9z58+c5cuQIZ86cISoqiqysrBL76Ovr89Zbb2FnZ8ewYcNKXPiqLvv27WPVqlWK57y2tjYODg7Mnz8fS0vLMo+TrzaTfwdWh+qUtTraunUr7u7uTJkyhVWrVmk6TqUTBUJBEARBENTuxIkTrFixggsXLpTYJkkSvXr1wsPDo0qs3hBZX02XLl2IjIxUOjFdneZ5ySUmJnLx4kX69eunaCeSmZnJ4sWLCQ0Npbi4WPHlS9NXXoqsVY8qCoT169cnNzeX+Ph4xQqwqtq6VWRVn3379jF58mT09fVZu3atYp7bP/8OUVFR2Nvbk5aWxtq1a5k4caLas06aNImff/6ZLl264O/vT82aNUvdLycnB2dnZy5dusTAgQPx8/NTc1KRtTJlZGRw7NgxgoKCOH78OBkZGVhaWjJgwAAcHR15++231ZJDUK/i4mJGjBjBb7/9VqJ4JUkSa9as4fjx4wQFBWFsbIydnR2mpqZERkYSHh6OTCajW7duBAUFvdRqmNeRlZVF//79FYUWe3t7Dhw4ADyfn21ra0t8fDw6OjoMGjSI1q1bU6NGDf78809+/fVXioqK6Nq1K4GBgWopEJ08eRIXFxdSU1MVv1tjY2MaNmyIgYEBurq65ObmkpWVRXx8vKJAJEkSZmZm7Ny5k3feeUflOeW5JEnCwsKCu3fv0rt3bzZu3FjlVtwVFhYyfPhwQkNDkclkWFtbc+LECeD546Nv377cvXsXmUxGly5daN26Nfr6+vz5559cvnwZSZLU+rq6Z88e5s6dS0FBgVLB2sTEBH9/f4KDg1m6dKlif319fXJzcxX7LVq0CDc3N7VkTUhIYMqUKYri6ouK2fBX8b1fv35s3rz5pVbIV5alS5eydu3aUnPWqFGDHTt2MHDgwFKPVffnx+qUtTrz9PRk1apVTJo0icmTJ2Nubq7pSJVGFAgFQRAEQdCYpKQkIiIiSE1NRVtbG1NTUzp06FCi7VBVILJWzJIlS0hISABg8+bNwPMvsa9CfqJb3ZYvX866desoLi7m7t27mJqaAjBo0CDOnDmj9EW8U6dOhISE8MYbmungL7JWTaooEFpaWhIbG8uoUaOws7MDYPr06UiSxObNm1/qhIvcmDFjKi1XaURW9Ro3bhyHDx9GkiTatWtHjx492L59O5IksXz5ciIiIjh8+DA5OTnY2tri7++vkVaOd+/excbGhoKCAszNzfHw8MDe3l6x6iY9PZ2QkBC8vb25c+cOkiQRFBRUotWfyFp9sxYVFREWFkZwcDBBQUE8ePCABg0aMHDgQAYOHEjv3r3/lTN+/ot27NjB3Llz0dXVZd68eQwbNgxDQ0PCw8OZN28e+fn5PHv2DHNzcw4fPqw0P/PChQuMHDmStLQ0vv76a8aPH6/SrEuWLGHt2rXUrVuXLVu2YG9vr9j2+eefs2nTJlq2bMnPP//MW2+9pXTs1atXGTp0KKmpqXh7ezN16lSVZr158yZ9+/YlJycHc3NzZsyYgb29PU2bNi3zmJiYGEJCQtiyZQu3b9/G0NCQU6dOqeUkt7wIkZSUxNKlS9m0aRN6enq4urryySefvFTrYXVYv349ixYtombNmnz11VeMGTMGfX194PlKPE9PT0xNTdmxYwe9evVSOjYoKIiJEyeSk5PDt99+y6hRo1Sa9c8//8Te3p6ioiIsLCxwcnJSPLdOnDiBlZUVDx8+JD8/n2XLljF69GjefPNNYmNjWbduHb6+vkiSxPHjx1W+Qi8tLY1evXoRFxeHjo4Ozs7O2NvbY2VlRcOGDTE0NFQqaD9+/Jjr168TEhJCQEAA+fn5tGjRgtDQULVcOBgaGsrgwYORJIkJEybg5uaGmZkZV65cYenSpYSHh6Ovr09oaGipn/HVWXSrTlmrsw8//BCAa9euKVbCGxgYUKtWrXIvXrl27Zpa8r0uUSAUBEEQBEEQhH84cOCAYmWNmZkZ58+fp3bt2oSFheHk5ESNGjXw9PRER0eHBQsW8PTpU1auXMmUKVNE1n9J1sqgigKhp6enovXl61L1yQCRVb0KCwtZtmwZPj4+5OfnI0mSUsFd3rZv1KhRrF69Wq3t5f4pODgYFxcXsrKyFL9zQ0NDJElSrHKRyWRoa2vj6emp8pPtIqtm3bp1i8DAQIKDg7l48SI1atSgT58+ODo64uDgoNZVI5VRhJIkiZ07d75+mHJUl5wODg6cO3eOxYsXl2hv//333zNz5kwkSeKHH34otRX9zp07mTNnDjY2NgQGBqo0a6dOnXj48CE7d+7k/fffL3Xbvn376N+/f6nHy1dyd+7cmZMnT6o068SJEzlw4AD9+vXjxx9/rFBBvbCwkNGjR3Ps2DFGjhzJtm3bVJj0uX8WIc6dO8f06dOJioqiTp06uLq6MnnyZI13jejevTt37txh/fr1Jdqg9ujRg9u3b7N9+3aGDx9e6vHbtm1j3rx5anm8TpgwgYMHD9KvXz/8/PyUVq1+8skniguEPvvsM6X26XIzZ87k+++/Z8SIEXz33XcqzfqiAnt57t+/z/Dhw3nw4AGzZ89WWhGpKqNHjyYwMJDhw4fj6+urtE2+yvTUqVN06tSJU6dOlfjsqM6iW3XK+uzZs0r5OWV1SFCl6tgJqSJEgVAQBEEQBEGodD/++GOl/SxNrMZxdHTk999/Z/LkyUpzBtzd3dm6dSvTp0/Hy8sLAD8/P6ZNm0bPnj0JDg4WWf8lWSuDKgqEMpmM7777jpMnT5Keng5AWFgYkiRhY2NToZ8VEBBQablKI7JqRnJyMr/88guXL18mKSmJoqIiTExMsLKywtnZmVatWmk0n1xcXBxr1qzh8OHDPHnyRGlbjRo1sLe355NPPqFz584aSvgXkVV9UlJSCAoKIigoiFOnTpGbm4u1tTVOTk588MEHNG7cWKX3b25uTlJSktJJ1IqsIAb1nBSsLjmbNm1KRkYGN27cKDFzMjo6GisrKyRJ4u7du5iZmZU4Pi4ujvbt21OrVi2io6NVmtXU1JSCggLi4uJKXEBhZmZGfn4+CQkJihVl/5SVlUWjRo0wNDTk0aNHKs0qnzl64cKFV1oBeOfOHbp160a9evW4e/euChIqK60IkZ+fz9atW1m3bh0pKSkYGBgwYsQIPvroI43NnJP/Oz948KBE55V69eqRl5dHbGwsb775ZqnHp6am0qJFC4yNjYmJiVFp1jZt2pCQkMCZM2dKzJi7cuUK7777LpIkcenSpVLf92/cuME777xD48aNuXHjhkqzduzYkejoaAICAir8mQpQXEjYokULrly5UvkB/+Gtt94iJSWF8PBw2rdvX2J7YmIiXbp0ITMzkw0bNjBu3Dil7eosulWnrPL7eh2SJGlkXmJYWNgrHVcVxtC8DFEgFARBEARBECpdZXwBkK920cSVd/ITWjdv3lRqdyW/ejgwMFAxt+XJkye0bNlSLSevRNbqRRUFwtJUp/ZAIqtQmpiYGJKTkyksLMTExISWLVuqfN7YqxJZ1ScvL4+TJ08SFBTE0aNH+fjjj0tdCVOZZDIZwcHBzJ8/nwcPHiBJEhMnTlS0w35Z8+fPV1HC56pLzrp161JYWFhq0S0vLw8zM7NyX2efPXtGgwYN0NHRISUlRaVZW7duTWJiInfu3KFevXpK21q2bElqaiqPHj0qsx1mdna2Yv7f48ePVZpVXshKTExET0+vwsfLf/f6+vokJiaqIKGy8t5Ps7Oz+eabb9i0aRPp6elIkkSTJk0YNGgQffr0wcbGRm0rhlq1asWTJ09KLRA2a9aM9PT0cn/nubm51KtXjxo1aihGLaiK/Ln199nJchkZGTRp0gRJkkhJSSm1VX9OTg7169dHV1eX5ORklWatbo9X+e82KSmpzNW5X3/9NQsXLqRevXpcuXJF6TGqzs+P1SnrwoUL2bdvn6JF56uSX8gnVJ7qOcxDEARBEARBqNJsbGxKLRAWFBRw7tw5xZ+NjY1p0qQJ2traREdHK76cGBkZMXHiRI3NnsvOzgZQamuWlpbG7du30dPTU7qyWX4VcVZWlnpD/n8iq+Dh4fHaBfmVK1fi4uJCnTp1KilV6URW1TA2NkZLS4vExMRqObutadOmNG3alPz8/CqfX2RVHz09PQYMGMCAAQMA9ZwUlCSJgQMHYmFhQZcuXZDJZEyZMkXlF3pUVHXJaWpqSnx8PDdu3KB79+5K2/T09JS6CZTm3r17wPMLblStW7du+Pv7s3v3btzd3ZW29ejRg8DAQE6fPs3AgQNLPf748eMAtGjRQuVZGzVqxIMHDzh37pxibm5FnD9/XvFzNM3AwAAPDw+mT5/O3r172b17N9euXcPHxwcfHx/eeOMNWrduTadOndi0aZNKs1hZWXHy5EkOHjyIi4uL0rZOnToRGhrKhQsXylwVFB4eDqDylc7wvM1iRkYGjx49KtGy880336RTp04AZX6XSkpKAihzRWxlMjExISEhgYcPH9K6desKHy+/UPCfRVtVMTY25smTJyQmJtKkSZNS95kxYwY7duzg4cOHLFq06IWvZapSnbIuXbqUBQsW4O7uzs6dO5EkiUOHDlWZzhZyPj4+ZGRkKF2QJB9D4OHhocFkqiMKhIIgCIIgCEKlK23uRmFhIcOGDQOgT58+fPbZZ/To0UNpn6tXr7JixQqCg4O5cuUKBw8eVEvef6pbty6JiYk8fPgQCwsLAE6cOIFMJqNr165KJ1rlbaTKuqJcZK2eWeVtcl+2xa2fnx/GxsY4OjoqbvPw8Kjwao5X8fnnn7/2z/D29mbw4MEqL2SJrKrRtGlTYmNjiYqKom3btiq9r8pSWFiIr68vv/76K7dv3yYlJQWZTEZaWhqRkZFs376dqVOnquVku8iqXvJW0pVFFasKW7VqhbW1NRcvXqz0n12ZqnrO7t27c+jQIRYsWIC/v3+JYsSLZgx//fXXSJKEtbW1KmMCz2eyBQQE4OXlhYGBAdOmTUNLSwt4PtMtODiYL7/8km7dupV4Tb9//z7z589HkqQy59NVpsGDB7N+/XpcXV3Zu3cv7dq1e+ljb968iaurK5IkMWTIEBWmrBgjIyMmT57M5MmTiYiIYNeuXRw7dozo6GiuX7/OjRs3VF4gnDZtGidOnGDBggXUr18fJycnxbaZM2dy6tQpFi5cSGBgYInHcmpqquIxMGjQIJXmBGjXrh1nz57lhx9+YPHixUrbJEkiNDS03OPl7ftfpUVtRdnZ2bF3714+/fRTfvrppxIrHsuTl5eHu7s7kiTRu3dv1YX8m86dO3P8+HG2bt3KsmXLSt1HR0eHtWvXMnToULZt20bv3r2VHi/qUp2yAujq6rJy5UoOHTpERkYGDRo0oGnTphrJUpalS5eSm5vLnDlzFI9VT09PUSAUBEEQBEEQhNf19ddfc/r0aUaOHMm2bdtK3adjx47s3buX6dOn4+fnx9dff80nn3yi5qTPT2gdOXIELy8vfH19ycvLY8OGDUiSpFjJILd161aAV7oitjKIrKoxffp0tLS0XrpA6OHhgZaWFg8fPlS6rbqo6OwqTRJZS5o1axbu7u74+vpq7MrwioiKimLYsGFER0cr/Y7kKzazsrLYvHkzu3btYtu2bTg7O2sqqsiqAvITbS9L3nK8rNtV1Xa0c+fOVbbw9ndVOefs2bPx9/fnwoULdO7cGWdnZ5o1a4arq2uZxzx+/JioqCh27drF/v37kSSJyZMnqzxr9+7d8fLywsPDg88//xwfHx+cnJzo3LmzIvOGDRvo0aMHEydOpEOHDuTn53Pu3Dl+/PFHMjMzsbKyYubMmSrPOm/ePI4cOcL9+/fp1asX/fr1w97eHktLSxo2bIihoSG6urrk5eWRlZXF48ePiYiIICQkhJCQEAoLCzE3N2fevHkqz/oqLC0tWb16NfC8+HrixAlOnTql8vt1cHBg7ty5rF+/nrFjx9KtWzeGDBmCtbU17du3x83NjXXr1tGnTx9mzpyp9Bjw8fHh0aNHNGnSBDc3N5VnHTlyJH/88QcbNmygsLCQESNG0KxZM2rVqvXCY0+ePMny5cvVViR2d3cnICCA0NBQunXrxtSpU+nXr1+5n/Fv375NSEgIW7duJTo6GiMjIz799FOVZwX4+OOPOXbsGBs3biQ9PZ3x48fTtm3bEq1u+/bty+TJk9m2bRsTJ07E09OT8ePHqyVjdcwqp6enh62tbakXFFcFpqamxMbG4ubmVmKFtp+fX4U+27/s90hNEzMIBUEQBEEQBLXo3r07d+7c4dKlSy9sJfLgwQM6deqEhYUFFy5cUFPCv5w7dw4HBwfg+dyM4uJikpOTMTQ05Nq1a9SpU4czZ86wZMkSxUm5FStWMGPGDJG1mmaNjY0lJiZG8WdHR0ckSSIwMPCFXwRjYmKYMWMGenp6Kp85oyrqmpdYGUTW0nl6erJq1SomTZrE5MmT1bIq4FWkp6djY2NDbGwsrVq1wt3dHWtra7p27aqYg5ORkYGbmxv79+9HX1+f8PDwEi3URNbqm3X37t3ExsayZs0aioqKeOONN2jbti2NGzdGR0eHmJgYbt26RV5eHlpaWgwZMqTcFSebN29WSc6rV68SHh7O6NGj1dba7lVU9Zz79+9nzpw5ipbhL5p31ahRI7KzsxXvvfPmzePLL79UR1QAzpw5w5dffsnly5cBXljMlheqhw8fzrp16zAyMlJHTJ48eYKrqytBQUHAi3PCXxetODs7s2HDBpWvbperbjN9/fz8WLp0KY8fP37pixlkMhndunVjx44damkxWlxczJgxYwgKClJklCSJtLS0Mo8ZMWIEt27dIi4uDplMRocOHQgJCanQir5X9ccff/Dxxx+TkJCgyKujo0ODBg0wNDRER0eH/Px8srKySEhIoKCgAHj+e23QoAG7du0q0aZYlebNm8e2bduUfrfbt29XdMORKywsZMyYMRw9ehRJknjzzTfJyMhQ6+O9OmWVW758OatWreLcuXNV7vO8p6enoqXo66our3miQCgIgiAIgiCoRb169cjLyyM5ORkdHZ1y9y0oKKBu3bpqG0Zfmp07d+Lh4UFubi7wvNXlN998o/iytXHjRhYsWAA8b51z6NAhjc1MFFlfn6enJ97e3q98vLxNakhISCWmUh9RdFMNdWX98MMPAbh27Rrx8fHA8+dWrVq10NbWLvO4a9euqTRXaby9vVmxYgUdO3YkICBAMW+0tBPI06ZNw8/PjwkTJrB+/XqR9V+SNTU1FVtbWx4/fsyECRP43//+V+KEelJSEqtXr2bLli1YW1sTHBxcLecoCs89efKEAwcOcOnSJZKSkjh06FCZ+zZo0ACAXr16MX36dPr06aOumEouX77M0aNHuXLlCvfu3SM5OZlnz55RVFSEgYEBJiYmmJub07NnTwYPHqyxizIiIiI4dOgQYWFhREZGkpqaWmIfExMTLCwssLW1ZejQoXTo0EGtGatbgRAgPz+foKAgxWMgKipK8dlVTldXlxYtWtCzZ0+GDBlC37591ZpRJpPh6+vL7t27uX79OoWFheXOam3YsCHZ2dloa2szbNgwVq1apdaLCp49e8bOnTv55ZdfuHjxIkVFRWXu+8Ybb9ClSxeGDh3K+PHj1VLE/KdffvmFb775hj///JOioiJ27NhRougGUFRUhLe3N5s2bXrpCyH+y1nh+Xf9Z8+eYWRkVCmFuMokk8n47rvvOHnypOL5FBYWhiRJ2NjYVOhnBQQEqCJipRMFQkEQBEEQBEEtmjdvztOnTwkPD6d9+/bl7hsREYGtrS116tTh/v37akpYUkpKCn/88Qc6OjpYW1srzZMLCgoiODgYOzs7hg4dqphToyki6+vx8fFRWoUSExODJEk0adLkhcdKkkTz5s3x8vKq0BygqkQU3VRDXVmNjY0rfIymTtba2Nhw48YNAgIClE60lHYC+datW/To0YNmzZpppJgpsqrGZ599xubNm5k9e3aZM5PkFi9ezPr16/nss89U1kpUrqxWplVNdckJr5Y1Pj6eevXqafyzSnWVk5NDdnY2eXl56OnpYWBgoJHiyt/JOzRUtVljFZWZmakoEtesWRMjI6Mq8zgtKCggNTWVevXqlbnP+vXradKkCXZ2dmqZkV2e3NxcHjx4QGxsbInHa5MmTWjZsiV6enoazSiXlZVFdHQ09evXL3fVbU5ODqdOneLq1as8evSIjRs3qjHlc9Upa3VSHS9yqAhRIBQEQRAEQRDUYvjw4fz22284ODjw008/lXnCSCaTMXLkSI4fP07//v3Zt2+fmpMKwr//i+A/iaKbaqgra1hY2CsdZ2trW8lJXqxhw4Y8e/asxGry0p5zeXl5mJmZoaurS3Jyssj6L8lqZWVFTEwMN2/epGHDhuXuGx8fT5s2bTA3N1f5nL3mzZszYMAAHB0dee+99zAwMFDp/b2q6pITnmd1cHDAycmpymcVBEEQhNKsWLECSZKYP3/+K/+MlStX4uLiorbWzhWhmb5CgiAIgiAIwn/OzJkzCQkJ4ejRowwZMoSFCxfSpUsXpX0uXLjA0qVLOX36NJIkMWvWLA2lFf7rRo8eXW1WaAiCJgp9r0pevEpPT6du3brl7itvMa2p1S8iq2rI2+C+KCegOJEWGxur0kwAn376KcHBwUycOBEtLS1sbGxwcnJi4MCBNGrUSOX3/7KqS06oXllfxrFjxwgODla0mzQxMeHtt99m+PDhL5yvrWq3bt0iMjKSmJgYsrOzycnJQVdXF0NDQxo1aoSFhQWWlpYayWZlZUWNGjXw9PRUexvO/4rExET++OMPsrOzadasGV27dn3hCrzAwEDg+dxtTUhNTVWsIHz27JliBWHjxo0xMzPTSKaKyM/P5+LFiyQkJFC3bl26du2q0dW6hYWFXLt2TfEYeJkVu9evXwdQe9vhlzF//nwkSWLFihWajsLnn3/+2j/D29ubwYMHV8kCoVhBKAiCIAiCIKjNmjVrWLp0qaLwYmRkROPGjZEkibi4ONLT05HJnn88XbJkCXPnzlV5pi5dunDv3j0kSSItLQ0AZ2fnCv8cSZLw9/ev7HhKRFZBVcSqPNVQRVYfHx8yMjKU2i16eXkhSRIeHh6Vdj+q4uzsTFhYGF999RWurq6K20tb6ebr64ubmxvdu3fn2LFjIuu/JKuFhQVJSUkcPXqU7t27l7vvuXPn6N+/v1pbjmdkZHDs2DGCgoI4fvw4GRkZWFpaKlbtvf3222rJ8SLVJSdUn6zm5uZoaWlx584dpdvj4+MZP34858+fB1B8VoXnn1O0tLSYOHEiK1asUOuszPv377Nhwwb8/f158uTJC/c3MTHh/fffZ+7cuWpt9yl/HZIkCTc3N+bPn//CeeTCy8nLy8Pd3Z0ffviB4uJixe2mpqZ88cUXfPzxx2Uea2xsjJaWluJzuqoVFxdz8OBBjhw5wpkzZ8q9XyMjI+zs7Bg+fDjvv/++2i/ai4uLY+fOnVy/fh1JkrCysmLSpEmK1qyHDh3i008/VVqFX7NmTdzc3HB3d1drVoDVq1fz9ddfk5mZqbjN0tKSRYsWYW9vX+Zx6n4MVMS/rZtLVf7+IgqEgiAIgiAIglqdOHGCFStWcOHChRLbJEmiV69eeHh4qG1FTJcuXYiMjFT6AlJV53mJrOqXmJjIxYsX6devn+KkX2ZmJosXLyY0NJTi4mIcHByYP38+RkZGGsv5uqryl9Z/+q9nrV+/Prm5ucTHxyuuVK9OJ1H27dvH5MmT0dfXZ+3atYwdOxYo+XeIiorC3t6etLQ01q5dy8SJE0XWf0nWSZMm8fPPP9OlSxf8/f2pWbNmqfvl5OTg7OzMpUuXGDhwIH5+fmpOCkVFRYSFhREcHExQUBAPHjygQYMGDBw4kIEDB9K7d2+1FoSqe06o2llLey3NysqiT58+REZGAvDee+8p5mRnZGRw9uxZgoKCKCoqwsnJiT179qgl648//oibmxt5eXnIZDL09PSwsLCgYcOGGBgYoKurS15eHpmZmcTHxxMZGUl+fj6SJFGjRg02bdrEsGHD1JJV/nu1s7MjNDSUtm3bsnHjRrp27aqW+/+3Ki4uZujQoYSGhiKTyWjatCmmpqbcu3eP9PR0RUF20aJFpR6vzs8ON27cYPz48dy7d0+pwG5gYKB4vObm5ipWv8pJkkS7du3YtWsX5ubmKs8J8MsvvzBt2jRyc3MVWSVJokGDBvj7+3Pr1i3GjRtHcXExJiYmNGzYkEePHpGWloYkSXz00Udqnek3depU9u7dq3gdMDIyUhQutbW1WbVqFS4uLqUeW5U/P1blbK+iKn9/EQVCQRAEQRAEQSOSkpKIiIggNTUVbW1tTE1N6dChA7Vr11ZrjiVLlpCQkADA5s2bAV755I78hKyqiKzqtXz5ctatW0dxcTF3795VXDU8aNAgzpw5o3TSoFOnToSEhPDGG9VzikNV/tL6T//1rJaWlsTGxjJq1Cjs7OwAmD59OpIksXnzZqUTby8yZsyYSstVEePGjePw4cOKE389evRg+/btSJLE8uXLiYiI4PDhw+Tk5GBra4u/vz9aWloi678k6927d7GxsaGgoABzc3M8PDywt7enVq1awPM2qSEhIXh7e3Pnzh0kSSIoKIiePXuqPes/3bp1i8DAQIKDg7l48SI1atSgT58+ODo64uDg8FJtU9WhuuSEqpW1tBPSXl5eeHp6YmxsjJ+fHzY2NiWOu3r1KkOHDiU1NZVt27YxYsQIleY8e/Ysjo6OFBUV0atXL+bOnYudnV25hdX8/HxOnz7Nxo0bOXXqFDo6OgQHB5do968Kf/+9bt26lcWLF/Ps2TNGjBjBokWLaNy4scoz/Bvt2rWL2bNno6enx+bNmxk+fDjw/OIKb29v1q1bhyRJ7NmzBycnpxLHq6sAExsbS69evUhLS8PExITx48djb2+PpaVlqRcPpqWlcePGDUJCQvj+++9JSUnB1NSUsLAw6tevr9KsN27coHfv3uTn59OhQwcGDBiAtrY2wcHBXL16lTZt2pCamkpaWhrr169n7NixSJKETCZj165d/O9//6OoqIj9+/eXu3Kvshw+fJhx48ahpaXFwoULmTFjBnp6esTHx7NgwQL279+PtrY2gYGB9OjRo8Tx6izCtWzZskL7P3nyBEmSMDExUdwmSRJRUVGVHU0tqvL3F1EgFARBEARBEARB+IcDBw4oVtaYmZlx/vx5ateuTVhYGE5OTopZOjo6OixYsICnT5+ycuVKpkyZouHkr6Yqf2n9p/96Vk9PT0VL0delqauyCwsLWbZsGT4+PooVLX8vuMtkMiRJYtSoUaxevRpDQ0ON5BRZVSc4OBgXFxeysrIUj2VDQ0MkSVK0SJPJZGhra+Pp6cnUqVM1lrUsKSkpBAUFERQUxKlTp8jNzcXa2honJyc++OCDKlP0qC45QfNZSztZ3qNHD27fvs26deuYMGFCmcfu2bOHGTNm8O6773LkyBGV5vzwww8JDg5mzJgxiouwKmL69On8+OOPODk58eOPP6ogobJ//l4fPHiAq6sr4eHh6OrqMmbMGGbPnq3xOY4AX3755Wv/DEmSWLp0aSWkKd+AAQM4e/Ys8+fPL7VOY7iWAACVVUlEQVTF+BdffME333yDmZkZf/75J2+++abSdnUVh2bPns2uXbuwtrbm559/rtAMtqdPnzJs2DD+/PNPJkyYwLp161SY9K8V7k5OTnz//fdoa2sDz1dr/t///R8BAQFIksSsWbNYtmxZiePnz5+Pj4+P2p5bQ4YMITQ0lMmTJ7Nq1aoS211cXNi/fz8tWrTg/PnzJS4iUGeBsGnTpqSnp7/Wz6jOKwqr8vcXUSAUBEEQBEEQ/tMq88ubqlfjiKzq4+joyO+//17iC7e7uztbt25l+vTpeHl5AeDn58e0adPo2bMnwcHBas9aGaryl9Z/+q9nlclkfPfdd5w8eVJxoiUsLAxJkkpd2VKegICASsv1KpKTk/nll1+4fPkySUlJFBUVYWJigpWVFc7OzlXiZLGcyFr54uLiWLNmDYcPHy4xP61GjRrY29vzySef0LlzZw0lfHl5eXmcPHmSoKAgjh49yscff6w0J7SqqC45QTNZSztZLm/rHBUVVW5hIzU1lRYtWlCrVi2io6NVmrNVq1Y8efKEiIgImjRpUuHjY2JisLS0pG7dumpZjVNWEcLf35/ly5dz+/ZttLS0ePfddxk/fjwDBgxQtNBWN1NTUwoKCl75ePmFGOoquGRkZHDlyhWaN29eYnt+fj5du3YlOjqauXPnsnjxYqXt6ioOtWvXjsePH3Pq1Ck6depU4eMvX75M7969ady4MTdu3Kj8gH/TunVrEhMTCQ8Pp3379krbbt68Sc+ePZEkiQsXLpTa8vTOnTt069YNMzMzRVtiVWrevDlPnz4tM09mZiadO3cmOTmZJUuWMGfOHKXt6iwQJiQkMG3aNE6ePIkkSUycOLHMNscymQxnZ2ckSeLXX39V2qauMSSVrSp/fxEFQkEQBEEQBOE/Tf7F6HWo62SAyKo+8pMuN2/epGHDhorb5SsJAgMDeeedd4DnLXBatmyplpOCqlKVv7T+k8ha0r9tTovw3xMTE0NycjKFhYWYmJjQsmVLxcqN6ig9Pf2V5u6qW3XJCerJWtpraZMmTcjMzCQpKancFp7Pnj2jQYMG6OrqKuZ/qUpps2grIicnh/r161OzZk3i4+NVkFBZee9RMpmMn376CS8vLx4+fKiYkfjee+/Rp08f7Ozs1DZ7DiAjIwM/Pz+8vLxITU1FkiQcHR0r/Nh7lZWdFSUvZiYnJ6Ojo1PqPr/++itjx45FX1+fixcvKhWU1fXZwczMjPz8fBITE9HT06vw8Xl5eZiZmaGvr09iYqIKEv6lbt26FBYWkpCQgL6+vtI2+fNGkqRStwPk5uZSr149dHR0SElJUWnWv+ct7zGwe/duZs2ahbGxMZcvX1a60EETnx+3bt3KokWLyMnJ4YMPPmDNmjWlPr/+bZ9tq/L3l+o5IEMQBEEQBEEQKomNjU2phayCggLOnTun+LOxsTFNmjRBW1ub6OhoxZcVIyMjJk6cqJbZcyKr+mRnZwMozT5KS0vj9u3b6OnpKc3skbdsysrKUm9IQfj/PDw8Xrsgv3LlSlxcXCrU+utVGBsbo6WlRWJiYrkn26sCkVV9mjZtStOmTcnPz69S+eUrxSuLqlbAVZecUL2yAlhbW3Pq1CkiIiKwtrYuc7+rV68CUK9ePZXmgeerhm7fvk1ISAiDBg2q8PEnTpxQ/BxNkySJ0aNHM2rUKI4dO8bu3bs5evQo/v7+ipVDRkZGdOzYEX9/f5XnMTIyYurUqXTt2pU+ffoAsHDhwip5Ur9evXrExcVx584dOnToUOo+zs7OvPvuu4SGhuLq6qry9relqVevHrGxsVy/fr3c51BZbt68CTwvNKpa7dq1SU5OJjo6mtatWytti4mJUfz/48ePS52pJy+4/7Odq6rUrVuXhIQEoqOjeeutt0rd56OPPuK7777j2rVrzJs3jx07dqglW1mmTJlCnz59mDJlCj///DO///4733zzDX379tVorv8yUSAUBEEQBEEQ/tMCAwNL3FZYWKhoedKnTx8+++yzEoPdr169yooVKwgODubKlSscPHhQZK2mWUtTt25dEhMTefjwIRYWFsDzE2oymYyuXbsqncB+9OgRAAYGBhrJKm/n+rKtWP38/DA2NsbR0VFxm4eHB6ampirJ93ciq2p8/vnnr/0zvL29GTx4sMoLhE2bNiU2NpaoqCjatm2r0vt6XSKrahUWFuLr68uvv/7K7du3SUlJQSaTkZaWRmRkJNu3b2fq1Km0aNFCYxk9PT0rVHyXr3wv63ZVFbOqS06oHllXr15NmzZtaNu2LTNmzODkyZMsWLCAI0eOlLpKJzs7mwULFiBJEr169ar0PP80YsQIli5dysyZM9HT06N///4vfezx48dxdXVFkiRGjhypwpQVI0kSDg4OODg4kJKSgp+fH8HBwZw/f5709HTOnDmj1jydO3fG0tKS69evq/V+K+Kdd95h7969LF68mL1795a56nrt2rXY2tpy+vRplixZwqJFi9Sas1+/fmzfvp25c+dy4MCBChX6kpOTmTNnjuLxoWo9e/bkyJEjeHt74+vrq7TN29tb8f9Hjhxh7ty5JY4/dOgQAFZWVirNKde1a1f8/f1ZvXo13377ban7SJLE+vXrsbe359ChQ7zzzjtMnjxZLfnKYm5uTkhICCtXrmT16tUMGzYMFxcXli9frrH2wv9losWoIAiCIAiCIPzDmjVrWLZsGSNGjGDbtm3l7jt9+nT8/PxYuHAhn3zyiZoS/kVkVY1x48Zx5MgRhg0bhq+vL3l5efTv35+rV6+yfPlyZs6cqdh3/vz5+Pj40K1bN44fP672rPKVQ2lpaS+1f9OmTdHS0uLhw4eqDVYKkbXqUlfro61bt+Lu7s6UKVOU5ntWRSKr6kRFRTFs2DCio6ORyf46LSVvJyafOVWzZk22bduGs7OzRnLu3r2b2NhY1qxZQ1FREW+88QZt27alcePG6OjoEBMTw61bt8jLy0NLS4shQ4aUe3JTVW0Hq0vOqp5V3ubu7wVJfX198vPzKS4uZtCgQXz//feKbdnZ2ezbt4+NGzcSFRWFnp4eoaGhKi/SFxQUMHDgQC5cuIAkSbRt25Z+/frRoUMHGjVqhKGhIbq6uuTl5ZGVlcWjR4+4fv06ISEh3Lp1C5lMRs+ePfn111/V0qnhdVoF5uTkcObMGU6dOsWKFSsqP1w53Nzc2LFjB2fPnq2SKwivX79O7969KSwsxMLCgrFjx9KmTRu6dOlS4mKfH374QVEYHjp0KK6urrz33ntqaeGYmJjIO++8w5MnT3jzzTcZPXo09vb2WFpaKlp2yhUXF5OQkEBERAQhISHs3buX9PR06tWrR3h4uMovurp06RL9+vWjuLiY7t274+TkhCRJBAQEcPbsWZo1a8bTp08pLCxk7969SvPwTp06xejRo8nJyWHr1q1qKcCHh4fj6OiIJEn07t2b8ePH07ZtW5o1a1bidXPVqlUsX74cLS0t5syZw4wZMzA3N9d4G89Lly4xZcoU7t27R6tWrdiyZQtdu3YVLUbVSBQIBUEQBEEQBOEfunfvzp07d7h06RKtWrUqd98HDx7QqVMnLCwsuHDhgpoS/kVkVY1z584prlQ2MzOjuLiY5ORkDA0NuXbtGnXq1OHMmTMsWbKEixcvArBixQpmzJih8myxsbFKbY7kJwYCAwOVTrSXJiYmhhkzZqCnp0dCQoKqo4qs1Yg6T1x4enqyatUqJk2axOTJk9U6X6qiRNbKl56ejo2NDbGxsbRq1Qp3d3esra3p2rWr4mRgRkYGbm5u7N+/H319fcLDw8tsn6ZKqamp2Nra8vjxYyZMmMD//vc/GjdurLRPUlISq1evZsuWLVhbWxMcHKz2NqnVJWdVzxoSEsK9e/cU/0VFRREXF0dxcTEA7dq1448//lDaf/jw4QDUrFmTzZs38/7776s8JzyfdbZw4UJ27txJXl7eS63KlMlk6OvrM3HiRBYvXvxK8+BeRXU90X/69GkCAwP53//+p5ZuAK9i//79zJo1i2fPnikeA76+voqOHX+3bt06lixZovizOmd9R0ZGMmHCBCIiIpQeq1paWtSsWRMdHR3y8/PJyclRPN/kGTt27MiOHTte+N2hsuzevRs3NzcKCwsVWWUyGXXq1CEgIIBLly4piq0dO3akUaNGxMbGEhERgUwmo2/fvoqVhOqwYcMGFi1aRHFx8QsfA25ubvj6+ir9varCczM3N5cFCxbw3XffoaWlxdy5c1mzZk2VyFZZRIFQEARBEARBEKqRevXqkZeXV+7Ad7mCggLq1q2Lvr4+iYmJakr4F5FVdXbu3ImHhwe5ubnA8xai33zzjeIL98aNG1mwYAEAdnZ2HDp0SC1X4nt6eiq1OaooeZvUkJCQSkxVOpG1+lDXiYsPP/wQgGvXrilm9RgYGFCrVq0y26PJ91c3kVU1vL29WbFiBR07diQgIEAxq6m0IsK0adPw8/NjwoQJrF+/Xu1ZP/vsMzZv3szs2bNZtmxZufsuXryY9evX89lnn6l8Lt4/VZecUL2yAuTn5xMVFcW9e/fIyMhg7Nixim0hISHMmTOHwYMH4+rqWqLQqQ7JyckEBgZy5swZIiMjiYuLIzs7m7y8PPT09DAwMKBx48ZYWFjQq1cvHB0dleYrq0N1LRBWF7GxsezYsYOTJ09y//59vv766zIL1adPn2blypWEh4crCkrq/HcJDAzk4MGDhIWFKd6rStOwYUNsbW0ZNmwYAwcOVFs+uTt37uDr60tERARaWlpYWloyY8YMmjRpAsCmTZtYsmQJeXl5imMkSWLUqFGsW7dO7W0yL168iI+PD6GhoaSkpLBjx45SC4QAe/bswdvbm+joaIAq9dw8ceIEM2bMICEhocoULyuLKBAKgiAIgiAIQjXSvHlznj59Snh4OO3bty9334iICGxtbalTpw73799XU8K/iKyqlZKSwh9//IGOjg7W1tZKV5AHBQURHByMnZ0dQ4cORUtLSy2ZfHx8lFqqxcTEIEmS4qRFeSRJonnz5nh5edGuXTtVxgRE1upEXScu5C38KkJTJ4hEVtWwsbHhxo0bBAQEYGNjo7i9tCLCrVu36NGjB82aNdNIMdPKyoqYmBhu3rxJw4YNy903Pj6eNm3aYG5urlhZri7VJSdU3axlzTosT3Fxsdre+wWhMqWnp3P9+nXi4uIUF5ioW3Z2NnFxcWRlZZGfn4+uri6GhoY0btxYY3O9KyIpKYnjx4+TmJhI3bp1sbOzo3nz5pqORWZmJjo6Oujr65e7382bN7ly5QqPHj3C3d1dTele7OnTp3z55ZeK738BAQEaTlQ5RIFQEARBEARBEKqR4cOH89tvv+Hg4MBPP/1U5gkjmUzGyJEjOX78OP3792ffvn1qTiqyCtXrynyRtepS14mLsLCwVzru73N+1EVkVY2GDRvy7NmzEqvJS3vO5eXlYWZmhq6uLsnJyWrPampqSkFBAUlJSS9scZmfn4+pqalGVr5Xl5xQdbM2b94cBwcHnJyceO+996pFgUIQBEGoHqpygVD1/W8EQRAEQRAEoZqZOXMmISEhHD16lCFDhrBw4UK6dOmitM+FCxdYunQpp0+fRpIkZs2aJbL+i7JWJ6NHj67wqgdNEVkFTRSkXpXIqhryomB6evoLWx3Ki0LqbtcmV7t2bZKSkrh8+TLdu3cvd9/Lly8DaKSwVF1yQtXN+umnnxIcHMzEiRPR0tLCxsYGJycnBg4cSKNGjVR+/0LV8/TpU2QyGbVr11a6vaCggEOHDnH9+nUyMzNp1KgRffv2pXPnzhrJ+eTJE+7evUvPnj2Vbi8qKuLQoUOEhoby+PFjdHV1eeutt3B2dn7hc0/VMjMziYqKIjY2lqysLHJychQtcRs1aoS5uTm1atXSSDZnZ2dq1KjBkiVLqk1XiOLiYqKjo2nRokWJbefPny/xGBgwYMBLdcjQhLy8PB4+fKh4bjVo0EDTkfjxxx8BGDNmzEvt7+fnh7GxMY6OjorbPDw8quwsU7GCUBAEQRAEQRBKsWbNGpYuXaooEBgZGdG4cWMkSSIuLo709HRksucfpZcsWcLcuXNF1mqatUuXLty7dw9JkkhLSwOenxyoKEmS8Pf3r+x4gqAWqriy2cfHh4yMDKXZYV5eXkiShIeHR6XdT2UQWdXH2dmZsLAwvvrqK1xdXRW3l7aC0NfXFzc3N7p3786xY8fUnnXSpEn8/PPPdOnSBX9/f2rWrFnqfjk5OTg7O3Pp0iUGDhyIn5+fyFmGqp41IyODY8eOERQUxPHjx8nIyMDS0pIBAwbg6OjI22+/rZYcgmYUFRWxatUqdu3apZiR16BBA+bNm4eLiwsJCQk4Oztz7949QLk17YABA9iyZcsrtXx+Fenp6cyfP599+/bRrl07Tp8+rdh29+5dxo4dS2RkpCInoJT122+/VWsRLj09ne3bt3P48GGuXbumyFQWKysrhg8fjouLC4aGhmpK+dd7kb6+Pl5eXnz88cdqu++KKigoYM2aNWzbto1GjRopPQaSkpKYNGmS0m1y2trauLi48NVXX71wLnxlun//Pnv27OHmzZvIZDLat2+Pi4uLot20l5cXmzZtIjMzU3FMmzZt+OKLLxg0aJDacv6TsbExWlpaiu+JL9K0aVO0tLR4+PChaoNVElEgFARBEARBEIQynDhxghUrVnDhwoUS2yRJolevXnh4eFSJlRsi66vr0qULkZGRSiemq9M8L7nExEQuXrxIv379FG3bMjMzWbx4MaGhoRQXF+Pg4MD8+fMxMjLSWE6RtWpSRYGwfv365ObmEh8fr1gBVlVbt4qs6rNv3z4mT56Mvr4+a9euZezYsUDJv0NUVBT29vakpaWxdu1aJk6cqPasd+/excbGhoKCAszNzfHw8MDe3l5xUj09PZ2QkBC8vb25c+cOkiQRFBRUYiWPyFk9sxYVFREWFkZwcDBBQUE8ePCABg0aMHDgQAYOHEjv3r1f2CZVqD6Ki4sZMWIEv/32W4nilSRJrFmzhuPHjxMUFISxsTF2dnaYmpoSGRlJeHg4MpmMbt26ERQUhLa2tkqzZmVl0b9/f0Whxd7engMHDgDP52fb2toSHx+Pjo4OgwYNonXr1tSoUYM///yTX3/9laKiIrp27UpgYKBaCkQnT57ExcWF1NRUxe/W2NiYhg0bYmBggK6uLrm5uWRlZREfH68oEEmShJmZGTt37uSdd95ReU55LkmSsLCw4O7du/Tu3ZuNGzdWuRV3hYWFDB8+nNDQUGQyGdbW1pw4cQJ4/vjo27cvd+/eRSaT0aVLF1q3bo2+vj5//vknly9fRpIktV58sWfPHubOnUtBQYFSwdrExAR/f3+Cg4NZunSpYn99fX1yc3MV+y1atAg3Nze1ZI2NjSUmJkbxZ0dHRyRJIjAw8IWF7ZiYGGbMmIGenh4JCQmqjlopRIFQEARBEARBEF4gKSmJiIgIUlNT0dbWxtTUlA4dOpRoOVQViKwVt2TJEsUXuM2bNwPPv8S+CvmJbnVbvnw569ato7i4mLt37ypa2AwaNIgzZ84ofRHv1KkTISEhvPGGZiZOiKxVkyoKhJaWlsTGxjJq1Cjs7OwAmD59OpIksXnz5heeZPm7l23r9KpEVvUaN24chw8fRpIk2rVrR48ePdi+fTuSJLF8+XIiIiI4fPgwOTk52Nra4u/vj5aWlkayBgcH4+LiQlZWlmL1jaGhIZIkKU5iy2QytLW18fT0ZOrUqSLnvyjr3926dYvAwECCg4O5ePEiNWrUoE+fPjg6OuLg4PDClrlC1bZjxw7mzp2Lrq4u8+bNY9iwYRgaGhIeHs68efPIz8/n2bNnmJubc/jwYcWqJ3jeIn/kyJGkpaXx9ddfM378eJVmXbJkCWvXrqVu3bps2bIFe3t7xbbPP/+cTZs20bJlS37++WfeeustpWOvXr3K0KFDSU1NxdvbW+XPr5s3b9K3b19ycnIwNzdnxowZ2Nvb07Rp0zKPiYmJISQkhC1btnD79m0MDQ05deoU5ubmKs0KfxUIk5KSWLp0KZs2bUJPTw9XV1c++eSTKjOfdP369SxatIiaNWvy1VdfMWbMGPT19YHnK/E8PT0xNTVlx44d9OrVS+nYoKAgJk6cSE5ODt9++y2jRo1SadY///wTe3t7ioqKsLCwwMnJSfHcOnHiBFZWVjx8+JD8/HyWLVvG6NGjefPNN4mNjWXdunX4+voiSRLHjx8vMZ5CFTw9PfH29n7l42UyGV27diUkJKQSU6mOKBAKgiAIgiAIgiBUYwcOHFCsrDEzM+P8+fPUrl2bsLAwnJycqFGjBp6enujo6LBgwQKePn3KypUrmTJlisj6L8laGVRRIPT09FS0vnxdql4ZJ7KqV2FhIcuWLcPHx4f8/HwkSVIquMvb9o0aNYrVq1ertb1caeLi4lizZg2HDx/myZMnSttq1KiBvb09n3zyicZmkMlVl5xQvbKWJiUlhaCgIIKCgjh16hS5ublYW1vj5OTEBx98QOPGjVV6/5VRgJIkiZ07d75+mBeoLlkdHBw4d+4cixcvLtHi/vvvv2fmzJlIksQPP/xQaiv6nTt3MmfOHGxsbAgMDFRp1k6dOvHw4UN27tzJ+++/X+q2ffv20b9//1KPl6/k7ty5MydPnlRp1okTJ3LgwAH69evHjz/+WKFVt4WFhYwePZpjx44xcuRItm3bpsKkz/1zNfu5c+eYPn06UVFR1KlTB1dXVyZPnqzxrhHdu3fnzp07rF+/vkQb1B49enD79m22b9/O8OHDSz1+27ZtzJs3Ty2P1wkTJnDw4EH69euHn5+f0qrVTz75RHGB0GeffabUPl1u5syZfP/994wYMYLvvvtOpVnheSt3+UWj8LxgLUnSS60ilSSJ5s2b4+XlVW1mWIoCoSAIgiAIgiAI/2nywfOVQROrcRwdHfn999+ZPHkyq1atUtzu7u7O1q1bmT59Ol5eXgD4+fkxbdo0evbsSXBwsMj6L8laGVRRIJTJZHz33XecPHmS9PR0AMLCwpAkCRsbmwr9rICAgErLVRqRVTOSk5P55ZdfuHz5MklJSRQVFWFiYoKVlRXOzs60atVKo/lKExMTQ3JyMoWFhZiYmNCyZUuVtxN8FdUlJ1SvrKXJy8vj5MmTBAUFcfToUT7++ONST3JXJnNzc5KSkpQuFKjI6mFQX2v06pK1adOmZGRkcOPGDRo1aqS0LTo6GisrKyRJ4u7du5iZmZU4Pi4ujvbt21OrVi2io6NVmtXU1JSCggLi4uJKXEBhZmZGfn4+CQkJihVl/5SVlUWjRo0wNDTk0aNHKs1qYWFBUlISFy5ceKUVgHfu3KFbt27Uq1ePu3fvqiChstJadufn57N161bWrVtHSkoKBgYGjBgxgo8++kgtK9pKI/93fvDgQYnuK/Xq1SMvL4/Y2FjefPPNUo9PTU2lRYsWGBsbK7XTVIU2bdqQkJDAmTNnsLS0VNp25coV3n33XSRJ4tKlS6W+79+4cYN33nmHxo0bc+PGDZVmLU11auP+KkSBUBAEQRAEQRCE/zT5l77XIV/tookvjvITWjdv3lRqdyW/ejgwMFAxt+XJkye0bNlSLSevRNbqRRUFwtJUp5MsIqtQnvz8/Goxf6665ITqlbU86enprzTLuCJkMhnBwcHMnz+fBw8eIEkSEydOVLTCflnz589XUcK/VJesdevWpbCwsNSiW15eHmZmZuW+zj579owGDRqgo6NDSkqKSrO2bt2axMRE7ty5Q7169ZS2tWzZktTUVB49elRmO8zs7GzF/L/Hjx+rNKu8kJWYmIienl6Fj5f/7vX19UlMTFRBQmXlvZ9mZ2fzzTffsGnTJtLT0xWrygYNGkSfPn2wsbGhZs2aKs8I0KpVK548eVJqgbBZs2akp6eX+zvPzc2lXr161KhRQ+Wz8uTPrb/PTpbLyMigSZMmSJJESkpKqa36c3JyqF+/Prq6uiQnJ6s0a2mmTZumaOP+b1Q9hyMIgiAIgiAIgiBUEhsbm1ILhAUFBZw7d07xZ2NjY5o0aYK2tjbR0dGKEwdGRkZMnDhRY7PnsrOzAZRmH6WlpXH79m309PSUrmyWX0WclZWl3pD/n8gqeHh4vHZBfuXKlbi4uFCnTp1KSlU6kVU1jI2N0dLSIjExsdoUgwoLC/H19eXXX3/l9u3bpKSkIJPJSEtLIzIyku3btzN16lRatGghcv6LsspXiVeWylxVKEkSAwcOxMLCgi5duiCTyZgyZYrKL/J4FdUlq6mpKfHx8dy4cYPu3bsrbdPT01PqJlCae/fuAc8vuFG1bt264e/vz+7du3F3d1fa1qNHDwIDAzl9+jQDBw4s9fjjx48DqOX51ahRIx48eMC5c+cUc3Mr4vz584qfo2kGBgZ4eHgwffp09u7dy+7du7l27Ro+Pj74+Pjwxhtv0Lp1azp16sSmTZtUmsXKyoqTJ09y8OBBXFxclLZ16tSJ0NBQLly4gK2tbanHh4eHA6i8HTJAzZo1ycjI4NGjRyVmYr755pt06tQJoMzvUklJSQBlrohVtW+//VYj96suokAoCIIgCIIgCMJ/WmlzNwoLCxk2bBgAffr04bPPPqNHjx5K+1y9epUVK1YQHBzMlStXOHjwoFry/lPdunVJTEzk4cOHWFhYAHDixAlkMhldu3ZVOgEvbyNV1hXlImv1zCpvk/uyLW79/PwwNjbG0dFRcZuHh0eFV3O8is8///y1f4a3tzeDBw9WeSFLZFWNpk2bEhsbS1RUFG3btlXpfVWGqKgohg0bRnR0tFJbRHlBNisri82bN7Nr1y62bdtW6mwykVNZdcnq6elZocK7vJtAWberou1oq1atsLa25uLFi5X+sytbVc/avXt3Dh06xIIFC/D39y9RjHjRjOGvv/4aSZKwtrZWZUzg+Uy2gIAAvLy8MDAwYNq0aWhpaQHPZ7oFBwfz5Zdf0q1btxKv6ffv32f+/PlIklTmfLrKNHjwYNavX4+rqyt79+6t0Fy2mzdv4urqiiRJDBkyRIUpK8bIyIjJkyczefJkIiIi2LVrF8eOHSM6Oprr169z48YNlRcIp02bxokTJ1iwYAH169fHyclJsW3mzJmcOnWKhQsXEhgYWOKxnJqaqngMDBo0SKU5Adq1a8fZs2f54YcfWLx4sdI2SZIIDQ0t93h5+/5XaVFbmRITE7l48SL9+vVTfA/IzMxk8eLFhIaGUlxcjIODA/Pnz9f4jMqK0NJ0AEEQBEEQBEEQhKrm66+/5vTp04wcOZJffvmlRHEQoGPHjuzdu5cxY8YQGhrK119/rYGkKK5yl690yMvLY8OGDUiSxIABA5T23bp1K/C8NZUmiKyqMX36dFxdXV96fw8PD2bMmFHiNlUXhipLRWdXaZLIWtKsWbOQyWT4+vqq5f5eR3p6OkOGDOHhw4e0bNmSb7/9lgsXLijt06pVKz744AOePXuGi4uLYhWRyFn9s27cuBF3d3e0tLSQyWRoa2vToUMHBgwYwKBBg+jYsSO6urqKAuDQoUMZPXp0if/GjBnD6NGjVZazc+fOKvvZla0qZ509ezZvvPEGFy5coHPnznz66acvLPI8fvyYM2fOMGnSJPbv3w/A5MmTVZ61e/fueHl5UVxczOeff46VlRUeHh7s3buXwsJCXF1diYyMpEePHnh6euLv78+BAwf49NNPsbOz4/Hjx1haWjJz5kyVZ503bx4tW7YkJiaGXr16MWrUKL777jvOnTtHbGwsaWlpZGdnk5qaSkxMDGfPnmXbtm18+OGH9OrVi+joaN566y3mzZun8qyvwtLSktWrV3Pt2jUuX77MmjVr1HJRg4ODA3PnzuXZs2eMHTuW/v37s2nTJs6ePUv79u1xc3Pj0qVL9OnThz179nD16lUuXLjAN998g62tLXfu3KFx48a4ubmpPOvIkSORyWRs2LCBBQsWcPXq1ZduiX7y5EmWL1+u8SLx8uXLadeuHf/3f/+nmP8Mzy/O2759O5GRkURFRbF582YGDx5MYWGhxrJWlJhBKAiCIAiCIAiC8A/du3fnzp07XLp0iVatWpW774MHD+jUqRMWFhYlTnKqw7lz53BwcACez3kpLi4mOTkZQ0NDrl27Rp06dThz5gxLlixRXLW/YsWKEgUikbX6ZI2NjSUmJkbxZ0dHRyRJIjAw8IVFnpiYGGbMmIGenp7KZ86oirrmJVYGkbV0np6erFq1ikmTJjF58mSNrwooi7e3NytWrKBjx44EBAQo2gmXNqNq2rRp+Pn5MWHCBNavXy9y/guypqamYmtry+PHj5kwYQL/+9//SrTjS0pKYvXq1WzZsgVra2uCg4PV3jr36tWrhIeHM3r06BKzyKqaqp51//79zJkzR9Ey/EWzXRs1akR2drbivXfevHl8+eWX6ogKwJkzZ/jyyy+5fPkywAtXvMqL2cOHD2fdunVqW+X05MkTXF1dCQoKAl6cE/66aMXZ2ZkNGzao7SKm6jbT18/Pj6VLl/L48eOXXvEsk8no1q0bO3bsUEuL0eLiYsaMGUNQUJAioyRJpKWllXnMiBEjuHXrFnFxcchkMjp06EBISEiJGYbqcODAASZOnAg8/05w/vx5ateuTVhYGE5OTtSoUQNPT090dHRYsGABT58+ZeXKlS9cdVxViBajgiAIgiAIgiAI//Dw4UPgeSu8F5F/sf57wUadunfvzvr16/Hw8CAxMRF43upy48aNipMpV65cURQv7ezsNPaFVWStHD/88APe3t6KP8tPtvy9ZWh55CdaBEETPvzwQwDq1avH1q1b2bp1KwYGBtSqVQttbe0yj7t27Zq6IiocOXIESZLw9PRUFLLKMmfOHPz8/Dhx4oSa0v2luuSE6pV15cqVPHr0iNmzZ7Ns2bJS9zEzM2PlypXUrFmT9evXs3btWpW0Ei1Px44d6dixo1rv81VV9awffPABffr04cCBA1y6dEkx+6wsxcXF1KhRg169ejF9+nT69OmjpqTP9erVi1OnTnH58mWOHj3KlStXuHfvHsnJyTx79oyioiIMDAwwMTHB3Nycnj17MnjwYLVflFGnTh1++uknIiIiOHToEGFhYURGRpKamlpiXxMTEywsLLC1tWXo0KHi88oLjB49muHDhxMUFKR4DERFRZGbm6u0n66uLi1atKBnz54MGTKEvn37qi2jlpYWfn5++Pr6snv3bq5fv/7CFXbh4eFkZ2ejra3NsGHDWLVqlUaKgwDbt29HkiQmT56sNIv08OHDAHz88cdMmDABAG1tbaZNm8bBgwerTYFQrCAUBEEQBEEQBEH4h+bNm/P06VPCw8Np3759uftGRERga2tLnTp1uH//vpoSlpSSksIff/yBjo4O1tbWSvPkgoKCCA4Oxs7OjqFDhyrm1GiKyPp6fHx82Lx5s+LPMTExSJJEkyZNXnisJEk0b94cLy+vCs0BqkrEqjzVUFdWY2PjCh+jqdUcDRs25NmzZyQnJ6Ojo6O4vbQVJnl5eZiZmaGrq0tycrLI+S/IamVlRUxMDDdv3qRhw4bl7hsfH0+bNm0wNzdX+Yy9smYdVkX/9qzx8fHUq1dP459VqqucnByys7PJy8tDT08PAwMDjRWB5OQX/L3MRYJVWWZmpqJIXLNmTYyMjKrM47SgoIDU1FTq1atX5j7r16+nSZMm2NnZqWVGdnmaNm1KRkZGifeCHj16cPv2bQIDA3nnnXeA56tlW7ZsSa1atYiOjtZU5AoRBUJBEARBEARBEIR/GD58OL/99hsODg789NNPZZ4wkslkjBw5kuPHj9O/f3/27dun5qSCUP3aYb0uUXRTDXVlDQsLe6XjbG1tKznJizVr1oz09HTu3btH3bp1FbeX9pyLiYnB0tISY2Njta8ory45q1tWU1NTCgoKSEpKemHb0Pz8fExNTdHX11esOleV5s2bM2DAABwdHXnvvfcwMDBQ6f29juqW1cHBAScnpyqfVRAE9alTpw5FRUVK7wVpaWm0aNECPT09YmNjFbfL3wveeOMNnjx5osnYL020GBUEQRAEQRAEQfiHmTNnEhISwtGjRxkyZAgLFy6kS5cuSvtcuHCBpUuXcvr0aSRJYtasWRpKK/zXjR49utqs0BAETRT6XpWlpSVhYWHs3bsXV1fXcvcNCQkB0EgxuLrkhOqVtXbt2iQlJXH58mW6d+9e7r7yGXDqKCp9+umnBAcHM3HiRLS0tLCxscHJyYmBAwfSqFEjld9/RYismnPs2DGCg4MV7SZNTEx4++23GT58+Avna6varVu3iIyMJCYmhuzsbHJyctDV1cXQ0JBGjRphYWGBpaWlRrJZWVkpZsqpsw3nf0liYiJ//PEH2dnZNGvWjK5du6Knp1fuMYGBgcDLt9OvTHXr1iUxMZGHDx9iYWEBwIkTJ5DJZHTt2lXpApJHjx4B6nkvqCxiBaEgCIIgCIIgCEIp1qxZw9KlSxWFFyMjIxo3bowkScTFxZGeno5M9vzr1JIlS5g7d67KM3Xp0oV79+4hSRJpaWkAODs7V/jnSJKEv79/ZcdTIrIKqiJW5amGKrL6+PiQkZGhNJPNy8sLSZLw8PCotPtRlX379jF58mT09fVZu3YtY8eOBUqudouKisLe3p60tDTWrl3LxIkTRc5/QdZJkybx888/06VLF/z9/alZs2ap++Xk5ODs7MylS5cYOHAgfn5+asmXkZHBsWPHCAoK4vjx42RkZGBpaalYsff222+rJcfLEFkrn7m5OVpaWty5c0fp9vj4eMaPH8/58+cBFJ9V4fnnFC0tLSZOnMiKFSteuDK2Mt2/f58NGzbg7+//UiurTExMeP/995k7d65a233KX4skScLNzY358+crtUMWXl1eXh7u7u788MMPFBcXK243NTXliy++4OOPPy7zWGNjY7S0tBSf09Vp3LhxHDlyhGHDhuHr60teXh79+/fn6tWrLF++nJkzZyr2nT9/Pj4+PnTr1o3jx4+rPeurEAVCQRAEQRAEQRCEMpw4cYIVK1Zw4cKFEtskSaJXr154eHiobUVMly5diIyMVDqJWlXneYms6peYmMjFixfp16+f4qRfZmYmixcvJjQ0lOLiYhwcHJg/fz5GRkYay/m6/utFN1VRRdb69euTm5tLfHy8Yq5UdWuJO27cOA4fPowkSbRr144ePXqwfft2JEli+fLlREREcPjwYXJycrC1tcXf318jc56qS87qlPXu3bvY2NhQUFCAubk5Hh4e2NvbU6tWLQDS09MJCQnB29ubO3fuIEkSQUFB9OzZU+1Zi4qKCAsLIzg4mKCgIB48eECDBg0YOHAgAwcOpHfv3motBpVHZK0cpb2WZmVl0adPHyIjIwF47733FHOyMzIyOHv2LEFBQRQVFeHk5MSePXvUkvXHH3/Ezc2NvLw8ZDIZenp6WFhY0LBhQwwMDNDV1SUvL4/MzEzi4+OJjIwkPz8fSZKoUaMGmzZtYtiwYWrJKv+92tnZERoaStu2bdm4cSNdu3ZVy/3/WxUXFzN06FBCQ0ORyWQ0bdoUU1NT7t27R3p6uqIgu2jRolKP1+Rnh3PnzuHg4ACAmZkZxcXFJCcnY2hoyLVr16hTpw5nzpxhyZIlihm0K1asYMaMGWrP+ipEgVAQBEEQBEEQBOEFkpKSiIiIIDU1FW1tbUxNTenQoQO1a9dWa44lS5aQkJAAwObNmwFe+eSOfNWGqois6rV8+XLWrVtHcXExd+/exdTUFIBBgwZx5swZxQoCSZLo1KkTISEhvPFG9Zw68l8vuqmKKrJaWloSGxvLqFGjsLOzA2D69OlIksTmzZuVVra8yJgxYyotV0UUFhaybNkyfHx8FCes//58kslkSJLEqFGjWL16NYaGhiLnvyhrcHAwLi4uZGVlKToKGBoaIkkSmZmZwPMVWtra2nh6ejJ16lSNZf27W7duERgYSHBwMBcvXqRGjRr06dMHR0dHHBwclOY/aprI+mpKK5h4eXnh6emJsbExfn5+2NjYlDju6tWrDB06lNTUVLZt28aIESNUmvPs2bM4OjpSVFREr169mDt3LnZ2duUWVvPz8zl9+jQbN27k1KlT6OjoEBwcXKLdvyr8/fe6detWFi9ezLNnzxgxYgSLFi2icePGKs/wb7Rr1y5mz56Nnp4emzdvZvjw4cDzFdje3t6sW7cOSZLYs2cPTk5OJY7X9MVFO3fuxMPDg9zcXOB5C9FvvvlGUbjeuHEjCxYsAMDOzo5Dhw5Vm8/ZokAoCIIgCIIgCIIgCNXYgQMHFO33zMzMOH/+PLVr1yYsLAwnJyfFLB0dHR0WLFjA06dPWblyJVOmTNFw8lfzXy+6qYoqsnp6eipair4uTa84TE5O5pdffuHy5cskJSVRVFSEiYkJVlZWODs7a3yml1x1yQnVJ2tcXBxr1qzh8OHDJVoj1qhRA3t7ez755BM6d+6soYTlS0lJISgoiKCgIE6dOkVubi7W1tY4OTnxwQcfVKmCh8j68kormPTo0YPbt2+zbt06JkyYUOaxe/bsYcaMGbz77rscOXJEpTk//PBDgoODGTNmjOIirIqYPn06P/74I05OTvz4448qSKjsn7/XBw8e4OrqSnh4OLq6uowZM4bZs2dXidenL7/88rV/hiRJLF26tBLSlG/AgAGcPXuW+fPnl9pi/IsvvuCbb77BzMyMP//8kzfffFNpu6YLhPD8Of/HH3+go6ODtbW14mI8gKCgIIKDg7Gzs2Po0KEaW6H/KkSBUBAEQRAEQRAEoZqozBMjql6NI7Kqj6OjI7///juTJ09m1apVitvd3d3ZunUr06dPx8vLCwA/Pz+mTZtGz549CQ4OVnvWyvBfL7qpiiqyymQyvvvuO06ePEl6ejoAYWFhSJJU6sqW8gQEBFRaLkF4VTExMSQnJ1NYWIiJiQktW7ZEW1tb07FeWl5eHv+vvTsPq7rO+z/++oKIKAEK2OQgY5qWuRY4WCKTk4ki6qhlqffdGI7m2mKjaD/HEfUGxDTNGZ2xdLaKtPJ2BVTSFNQxdFzoLlxIAU0BlUVcUOT8/nA4E4G4nYUjz8d1dV1zPudzvucFIy7f93m/P9u2bVNiYqI2bdqkESNGVDojtDYha82qK5hUjHXOzMyUt7f3TV97/vx5Pfzww/Ly8lJWVpZVc7Zq1Urnzp1Tenq6mjdvfsevz87OVocOHeTj46PMzEwrJKzsZoWo9evXa86cOcrIyJCTk5N+8Ytf6Ne//rV69+5tHqFta76+vrp27dpdv76iW9sWRTd/f38VFxfrwIEDatGiRZXnr169qi5duigrK0tvvPGGZs6cWen52lAgvF9RIAQAAAAAB1Hxj+N7YaubAWS1nYqbLt98842aNWtmXq/oJEhISNDTTz8tSTp37pxatmxpk5uC1lLXi27WYqusjnSTz9PTU05OTsrNza01Z6JVx1FySo6VtSZXr1516PwVioqK7urMXXsga2XV/V7avHlzXbhwQXl5eTX++rx06ZIeeugh1a9fX/n5+VbNWd1ZtHfi8uXL+slPfqKGDRvq9OnTVkhYWU1/RplMJn3yySeKjY3ViRMnzGckPvvss+rRo4dCQkLUunVrq2esUFxcrPj4eMXGxur8+fMyDENhYWF3/Gvvbjo771RFMTM/P18uLi7V7tmwYYOGDx+uBg0aaO/evZUKyo70dwdH4xiDUAEAAAAA6tatW7WFrGvXrmnPnj3mx56enmrevLmcnZ2VlZVl/se0h4eHIiIibHImBllt5+LFi5JU6eyjgoICZWRkyNXVtdKZPRUjm0pKSmwbEvi3yMjIey7Ix8XFaeTIkTV2yFiCv7+/cnJylJmZqbZt21r1ve6Fo+SUHCtrhbKyMq1YsUIbNmxQRkaGzp49K5PJpIKCAh09elTLly/Xq6++qocffthuGSu6xC3Fmt1vZLWegIAAffnll0pPT1dAQMBN9x08eFCS9OCDD1o1jyS1aNFCGRkZSk5OVr9+/e749Vu3bjVfx94Mw9DQoUP10ksvafPmzfr73/+uTZs2af369dqwYYOkG38n7NSpk9avX2/1PB4eHnr11VfVpUsX9ejRQ5I0Y8aMWvmhpAcffFAnT57U4cOH1b59+2r3hIeH6xe/+IW2b9+u8ePHW338bXUCAwN17NgxGYahgoICc647ZRiGTX4NWAIdhAAAAADgwMrKyjRo0CBt375dPXr00NSpU9W1a9dKew4ePKjo6GglJSXpmWee0erVq+0yEo2s1vHoo48qNzdXX331ldq0aSPpP+cSdu/e3XzTSrpxlk7nzp3l6emp7Oxsm2etGOd6u6NY4+Pj5enpqbCwMPPa3Llz9Zvf/MbqxSGy1l7e3t7auXOn1W+CLlu2TJMnT9bo0aMrje+tbRwlp+RYWSUpMzNTgwYNUlZWlkym/9xCrehk2b9/v5555hk1bNhQ77///l3dSLaEO+2Er+h6v9m6Nbt0yGrZbNOnT9djjz2mtm3bKjMzUy+88IKefvpprVu3rtpOrYsXL6p///7at2+fhg4davXusfnz52vWrFny8vLS+++/r169et32a7ds2aJRo0apsLBQv//97/Xmm29aMekNd9qpdvbsWcXHxyspKUlfffWVrl69apdOt+DgYH399df65z//WSsLhKNHj9bKlSv13HPPaeXKlTf9+/KxY8cUHBysK1eu6M0339Tvf/97SbbrIAwMDNTRo0crvdfddAM7UrcjBUIAAAAAcGDz58/X7Nmz9cILL+j999+vce/YsWMVHx+vGTNmaNKkSTZK+B9ktY6XX35Z69at06BBg7RixQqVlpaqV69eOnjwoObMmaMJEyaY906bNk1LlizRz3/+c23ZssXmWSvGC1Z8KvtW/P395eTkpBMnTlg3WDXIWnvZcnRrTEyM5s2bp9/85jcaNWqUTcfH3QlHySk5TtaioiJ169ZNOTk5atWqlSZPnqyAgAB16dLFfPO3uLhYb775pj777DM1aNBAO3fu1COPPGLzrH//+9+Vk5Oj+fPn6/r166pXr57atm0rPz8/ubi4KDs7W99++61KS0vl5OSkAQMG1Dju0ZpFI7JaRkXR4ocFyQYNGujq1asqLy9Xv3799I9//MP83MWLF7Vq1SotXrxYmZmZcnV11fbt263eyXvt2jX16dNHaWlpMgxDbdu21XPPPaf27dvrpz/9qdzd3VW/fn2VlpaqpKREp06d0tdff63k5GR9++23MplMeuqpp7RhwwabTGq4l0LU5cuXlZKSoi+//FLR0dGWD1eDN998U3/5y19qbYHw66+/1jPPPKOysjK1adNGw4cP12OPPabAwMAqH0z68MMPNX78eBmGoYEDB2r8+PF69tlnbVJ0i4qK0pkzZyT95+f1o48+uqtrDR8+3GK5rIkCIQAAAAA4sKCgIB0+fFj79u1Tq1atatxb0T3Wpk0bpaWl2Sjhf5DVOvbs2aPQ0FBJUtOmTVVeXq78/Hy5u7vr0KFD8vb2VkpKiqKiorR3715JUnR0tMaNG2f1bDk5OZU6FcPCwmQYhhISEip141QnOztb48aNk6urq/lmjTWR1XHYqkD44osvSpIOHTpkPvuqUaNG8vLyqrFb+NChQ1bN9WOOklNyrKxz585VdHS0OnXqpI0bN5pHNFdXQBgzZozi4+P1yiuvaOHChTbPev78eQUHB+v777/XK6+8orfeekt+fn6V9uTl5emdd97Rn//8ZwUEBCgpKcku5yiS1TKSk5N17Ngx83+ZmZk6efKkysvLJUmPP/64du/eXWn/4MGDJUkNGzbU0qVL9atf/crqOSXpypUrmjFjhv7617+qtLT0troyTSaTGjRooIiICM2cOVOurq42SOq4Z93t2LFDCQkJeuutt+Tr62vvONX67LPPNHHiRF26dMn8a2DFihUaNGhQlb3vvvuuoqKizI/tedb3/Y4zCAEAAADAgVV0APn7+99yb8VNLXuMlpTIai1BQUFauHChIiMjlZubK+nGDffFixebP5V94MABc/EyJCREo0ePtkm2Dz/8UHPnzjU/rrgh9MPRljUxmUw3PavG0siKH0tKSqqyVlJSUuMZnvd6vuLdcJSckmNlXbdunQzDUExMjLk4eDOvv/664uPjzeel2VpcXJxOnTql1157TbNnz652T9OmTRUXF6eGDRtq4cKFWrBggdXPxKsOWS2jZ8+e6tmzZ6W1q1evKjMzU8eOHVNxcXGV1/j5+al///4aP358lUKnNTVo0EBxcXGaPHmyEhISlJKSoqNHj+rkyZO6ePGiSktL5erqqkaNGsnPz09t2rRR9+7dFRYWVul8ZdxcSEiIQkJC7B2jRs8//7yCgoL0l7/8Rdu2bdN3330nJyenave++eabCggIUFxcnHbu3HnLDz9ZSsXIdku43bHv9kYHIQAAAAA4sBYtWqiwsFA7d+5Uu3btatybnp6u4OBgeXt767vvvrNRwv8gq3WdPXtWu3fvlouLiwICAip9gjwxMVFJSUkKCQnRwIEDb3pDxtKWLFlSaaRadna2DMNQ8+bNb/lawzDUokULxcbG6vHHH7dmTElkdSS26iBMTU29q9cFBwdbOEnNHCWn5FhZmzVrpkuXLik/P7/SWW7VdRiVlpaqadOmql+/vvLz822etWPHjsrOztY333yjZs2a1bj39OnTeuyxx9S6dWtzV7ktkfXe3eysw5qUl5fb7M9+wJKKior09ddf6+TJk+YudGu503NHq+No3Y4UCAEAAADAgQ0ePFhffPGFQkND9cknn9z0H7Umk0lDhgzRli1b1KtXL61atcrGSckKxxrdRdbay5ZnEKLu+tnPfqaioiIdO3asUhdTdT9v2dnZ6tChgzw9Pe3STe7r66tr164pLy/vluMtr169Kl9fXzVo0MDcdW5LZL13LVq0UGhoqPr27atnn31WjRo1sur7AXVFxcj2H7t27Zr27Nljfuzp6anmzZvL2dlZWVlZ5j8PPDw8FBERoXr16ul3v/udrWLfEz42AAAAAAAObMKECTKZTNq0aZMGDBhQ7afW09LS1L9/f23evFmSNHHiRFvHlERWSEOHDtXQoUPtHeO2kLVuWbJkiWJjYyutxcbGVhrlWhs4Sk7JsbJWp0OHDpKklStX3nJvcnKyJNmtaN24cWNJ0v79+2+5t2KPvYpKZL13U6ZM0enTpxUREaGHH35YAwcO1AcffKBTp05Z/b1ROxUWFqqgoKDK+rVr17Rq1SrNmDFDb775pt555x3961//skPCG86dO1fpbMwK169fN59ROHjwYA0dOlS/+93vKhXlbCEhIUEbN26s9N/atWvVoEEDSVKPHj20adMmZWdna+fOndqxY4eysrK0Y8cO9e7dW8XFxTpw4IDefvttm+a+F3QQAgAAAICDmz9/vmbNmmX+xKuHh4f8/PxkGIZOnjypoqIi89kdUVFReuONN8jqoFkDAwN17NgxGYZhvhEUHh5+x9cxDEPr16+3dDzAJqzRQfiTn/xEV65c0enTp+Xm5iapdnZmOkpOybGyVmfVqlUaNWqUGjRooAULFmj48OGSqn4NmZmZ6tmzpwoKCrRgwQJFRETYPOtvfvMbffrppwoMDNT69evVsGHDavddvnxZ4eHh2rdvn/r06aP4+HgbJyWrJRUXF2vz5s1KTEzUli1bVFxcrA4dOqh3794KCwvTE088YZMcsI/r169r3rx5+tvf/qbTp09Lkh566CH99re/1ciRI3XmzBmFh4fr2LFjkiqPpu3du7f+/Oc/y9PT0yZZi4qKNG3aNK1atUqPP/64duzYYX7uyJEjGj58uI4ePWrOKalS1j/96U/y8vKySdYfmz9/vmbPnq0XXnhB77//fo17x44dq/j4eM2YMUOTJk2yUcJ7Q4EQAAAAAO4DW7duVXR0tNLS0qo8ZxiGunfvrsjISLuc4/RjZL17gYGBOnr0aKWb03dzc8feN+hzc3O1d+9ePffcc+axbRcuXNDMmTO1fft2lZeXKzQ0VNOmTZOHh4fdcpK1drJGgbBDhw7KycnRSy+9pJCQEEk3bvQZhqGlS5eab1jejmHDhlks1485Sk7JsbLezMsvv6y1a9fKMAw9/vjj6tq1q5YvXy7DMDRnzhylp6dr7dq1unz5soKDg7V+/Xq7nPN25MgRdevWTdeuXVPr1q0VGRmpnj17mm+oFxUVKTk5WXPnztXhw4dlGIYSExP11FNPkfU+yXr9+nWlpqYqKSlJiYmJOn78uB566CH16dNHffr00TPPPHPLMalwHOXl5XrhhRf0xRdfVPm91DAMzZ8/X1u2bFFiYqI8PT0VEhIiX19fHT16VDt37pTJZNLPf/5zJSYmytnZ2apZS0pK1KtXL33zzTcymUzq2bOnPv/8c0k3zs8ODg7W6dOn5eLion79+unRRx+Vm5ub/vWvf2nDhg26fv26unTpooSEhErnwdpKUFCQDh8+rH379qlVq1Y17j1+/Lg6d+6sNm3aVPtvh9qIAiEAAAAA3Efy8vKUnp6u8+fPy9nZWb6+vmrfvr15TFZtQtY7FxUVpTNnzkiSli5dKkn66KOP7upaFd0wtjZnzhy9++67Ki8v15EjR+Tr6ytJ6tevn1JSUip9crxz585KTk5WvXr1yHofZb1X1igQxsTEKDY29qbnjd4JaxbfHSWn5FhZb6asrEyzZ8/WkiVLdPXqVRmGUelnqaIj56WXXtI777wjd3d3u+SUpKSkJI0cOVIlJSXm77m7u7sMw9CFCxck3ejMcXZ2VkxMjF599VWy3mdZf+jbb79VQkKCkpKStHfvXrm5ualHjx4KCwtTaGhopXM14Xj+8pe/6I033lD9+vX129/+VoMGDZK7u7t27typ3/72t7p69aouXbqk1q1ba+3atWrWrJn5tWlpaRoyZIgKCgq0aNEi/frXv7Zq1qioKC1YsEA+Pj7685//rJ49e5qfe/vtt/XHP/5RLVu21KeffqpHHnmk0msPHjyogQMH6vz585o7d65dfr4efPBBlZaWKj8//5YFymvXrsnHx8du56beDQqEAAAAAADAJj7//HPz+L2mTZvqq6++UuPGjZWamqq+ffvKzc1NMTExcnFx0fTp01VYWKi4uDiNHj2arPdJVkuwRoHQZDLpgw8+0LZt21RUVCRJSk1NlWEY6tat2x1da+PGjRbL9WOOklNyrKy3kp+frzVr1mj//v3Ky8vT9evX1aRJE3Xs2FHh4eG37CqxlZMnT2r+/Plau3atzp07V+k5Nzc39ezZU5MmTdKTTz5pp4T/QVbbOXv2rBITE5WYmKgvv/xSV65cUUBAgPr27avnn39efn5+Vn1/SxSgDMPQX//613sPcwuOkjU0NFR79uzRzJkzq4y4/8c//qEJEybIMAx9+OGH1Y6i/+tf/6rXX39d3bp1U0JCglWzdu7cWSdOnNBf//pX/epXv6r2uVWrVqlXr17Vvr5i3POTTz6pbdu2WTVrdVq0aKHCwkLt3LlT7dq1q3Fvenq6goOD5e3tre+++85GCe8NBUIAAAAAABzExx9/bLFr2WNkX1hYmHbt2qVRo0Zp3rx55vXJkydr2bJlGjt2rGJjYyVJ8fHxGjNmjJ566iklJSWR9T7JagnWKBBWx1HOy3OUnJJjZXV02dnZys/PV1lZmZo0aaKWLVtafZTg3SKr7ZSWlmrbtm1KTEzUpk2bNGLECE2dOtWq79m6dWvl5eVV6ia+kxHDku1GoztKVn9/fxUXF+v//u//9NOf/rTSc1lZWerYsaMMw9CRI0fUtGnTKq8/efKk2rVrJy8vL2VlZVk1q6+vr65du6aTJ09W6bJu2rSprl69qjNnzqhBgwbVvr6kpEQ//elP5e7urlOnTlk1a3UGDx6sL774QqGhofrkk09u2hVvMpk0ZMgQbdmyRb169dKqVatsnPTuOOYsCQAAAAAA6qCK87vuRcVIPHsUCL/++mtJ0ptvvllpPSUlRYZhqH///ua1ik+Sf/vtt7YL+ANkRWRk5D3/vMXFxWnkyJHy9va2UKqqHCWn5FhZPT095eTkpNzcXIc8u83f31/+/v66evVqrc9PVttxdXVV79691bt3b0kyd/da05EjR5SUlKRp06bp+PHjMgxDI0eONI/Crk0cJeulS5ckVX8O9U9+8hPz/66uOCjd+KCNJF28eNEK6aq+V25uri5evFilQOju7q7z58/r+vXrN319xZ8Zd1qotZQJEyYoOTlZmzZt0oABAzRjxgwFBgZW2pOWlqZZs2Zpx44dMgxDEydOtEvWu0EHIQAAAAAADiIsLKzam+vXrl3Tnj17zI89PT3VvHlzOTs7Kysry/xJdg8PD0VERKhevXr63e9+Z6vYZt7e3rp+/bry8vLMN1YLCgr08MMPy9XVVTk5Oeb1q1evytfXV/Xq1asy0o2sjpvVEmzVQWgJ3t7e2rlzZ63P6ig5Jdtl7dChg3JycrR79261bdvWqu9lKWVlZVqxYoU2bNigjIwMnT17ViaTSQUFBTp69KiWL1+uV199VQ8//LC9o5LVwiq6xC3FGl2FmZmZCgwMlMlk0j//+c9a/ftNbc/atm1bnT59Wps2bVJQUFCV55ctWyZJNx0lfujQIXXv3l0PPvigjhw5YtWs//3f/63169fr//2//6fJkydXem7YsGFKSEhQfHy8+vTpU+3r16xZo1//+tdq3769du7cadWsNzN//nzNmjXL/HdwDw8P+fn5yTAMnTx5UkVFReYCZlRUVJWxr7UZHYQAAAAAADiI6s6JKSsr06BBgyRJPXr00NSpU9W1a9dKew4ePKjo6GglJSXpwIEDWr16tU3y/piPj49yc3N14sQJtWnTRpK0detWmUwmdenSpVI3RsUYqUaNGpH1PspaMSb3djtY4+Pj5enpqbCwMPNaZGRkrevmuBl7dTzcKUfJKdku68SJEzV58mStWLGi0uje2iozM1ODBg1SVlZWpe9RxQ3tkpISLV26VH/729/0/vvvV3suma2Q1fJiYmLuqDu3YprAzdatUSBs1aqVAgICtHfvXotf29Jqe9agoCD97//+r6ZPn67169dXGc95qzOGFy1aJMMwFBAQYM2Ykm504G3cuFGxsbFq1KiRxowZIycnJ0nSpEmTlJSUpN/97nf6+c9/XqUz/LvvvtO0adNkGIYGDx5s9aw389Zbb+mJJ55QdHS00tLSVFRUVKn71jAMhYSEKDIyUsHBwXbLeTec7B0AAAAAAADcvUWLFmnHjh0aMmSI1qxZU6U4KEmdOnXSypUrNWzYMG3fvl2LFi2yQ1KZP+Ve0elQWlqq9957T4ZhmMedVaj49Pujjz5q25D/RlbrGDt2rMaPH3/b+yMjIzVu3Lgqa9YeLwmMHj1aU6dO1fLlyzVlyhQdPXrU3pFuqqioSAMGDNCJEyfUsmVL/elPf1JaWlqlPa1atdLzzz+vS5cuaeTIkTp27BhZ76Osixcv1uTJk+Xk5CSTySRnZ2e1b99evXv3Vr9+/dSpUyfVr1/fXAAcOHCghg4dWuW/YcOGaejQoVbL+eSTT1rt2pZWm7O+9tprqlevntLS0vTkk09qypQp+uMf/1jja77//nulpKToN7/5jT777DNJ0qhRo6yeNSgoSLGxsSovL9fbb7+tjh07KjIyUitXrlRZWZnGjx+vo0ePqmvXroqJidH69ev1+eefa8qUKQoJCdH333+vDh06aMKECVbPWpNf/vKXSk5O1tGjR7V69Wp98MEH+stf/qINGzbo+PHjWr9+vcMVByVGjAIAAAAA4NCCgoJ0+PBh7du3T61atapx7/Hjx9W5c2e1adOmyk1OW9izZ49CQ0Ml3TgXp7y8XPn5+XJ3d9ehQ4fk7e2tlJQURUVFmT+1Hx0dXaVARFbHyZqTk6Ps7Gzz44oxuQkJCbfsBMvOzta4cePk6uqqM2fOWDuqVTjKOFRHySnZLuuLL74o6cYovtOnT0u60Xnr5eUlZ2fnm77u0KFDVs1Vnblz5yo6OlqdOnXSxo0b9cADD0i6MW7aMAzzmGlJGjNmjOLj4/XKK69o4cKFZL1Psp4/f17BwcH6/vvv9corr+itt96Sn59fpT15eXl655139Oc//1kBAQFKSkqy+TmKBw8e1M6dOzV06FA1btzYpu99p2p71s8++0yvv/66SkpKJKnKr8kf++lPf6qLFy+a/+z97W9/a9Nx8ykpKfrd736n/fv3S9ItO14ritmDBw/Wu+++Kw8PD1vErHMYMQoAAAAAgAM7ceKEJMnf3/+WeytuFv6wYGNLQUFBWrhwoSIjI5Wbmyvpxg33xYsXmzvCDhw4YC5ehoSE3HJMFllrd9YPP/xQc+fONT+uuCH4w5GhNTGZTGrfvr1VsgE1SUpKqrJWUlJivhlfnTsZ8WhJ69atk2EYiomJMRexbub1119XfHy8tm7daqN0lZHVOuLi4nTq1Cm99tprmj17drV7mjZtqri4ODVs2FALFy7UggULrDJKtCadOnVSp06dbPqed6u2Z33++efVo0cPff7559q3b5/y8vJq3F9eXi43Nzd1795dY8eOVY8ePWyU9Ibu3bvryy+/1P79+7Vp0yYdOHBAx44dU35+vi5duqTr16+rUaNGatKkiVq3bq2nnnpK/fv3V+vWrW2as66hgxAAAAAAAAfWokULFRYWaufOnWrXrl2Ne9PT0xUcHCxvb2999913NkpY1dmzZ7V79265uLgoICCg0nlyiYmJSkpKUkhIiAYOHGg+p8ZeyHpvlixZoqVLl5ofZ2dnyzAMNW/e/JavNQxDLVq0UGxsrB5//HFrxrQaR+nMc5Scku2ypqam3tXr7DFirlmzZrp06ZLy8/Pl4uJiXq+u0620tFRNmzZV/fr1lZ+fT9b7JGvHjh2VnZ2tb775Rs2aNatx7+nTp/XYY4+pdevWVj9j72ZnHdZG93vW06dP68EHH7T731VQu1AgBAAAAADAgQ0ePFhffPGFQkND9cknn9z0hpHJZNKQIUO0ZcsW9erVS6tWrbJxUqD6G+v3M0cpvDlKTsmxstrKz372MxUVFenYsWPy8fExr1f385adna0OHTrI09PTLt3kZLUOX19fXbt2TXl5ebccG3r16lX5+vqqQYMG5q5za2nRooV69+6tsLAwPfvss2rUqJFV3+9eOFrW0NBQ9e3bt9ZnRe1GuRgAAAAAAAc2YcIEmUwmbdq0SQMGDKi2GyAtLU39+/fX5s2bJUkTJ060dUxAkjR06FANHTrU3jGASpYsWaLY2NhKa7GxsZXG49ZmHTp0kCStXLnylnuTk5MlyW4FVrJaR8UZeRXnu9WkYo8tikpTpkzR999/r4iICD388MMaOHCgPvjgA506dcrq732nHC3r6dOnHSLr7di8ebMmTZqkAQMGKDQ0VEOHDlVcXJwyMzPtHe2+RwchAAAAAAAObv78+Zo1a5a5e9DDw0N+fn4yDEMnT55UUVGRTKYb//yPiorSG2+8YfVMgYGBOnbsmAzDUEFBgSQpPDz8jq9jGIbWr19v6XiVkBXW4ijdbo6SU7JO1p/85Ce6cuWKTp8+LTc3N0mO1e26atUqjRo1Sg0aNNCCBQs0fPhwSVW/hszMTPXs2VMFBQVasGCBIiIiyHqfZP3Nb36jTz/9VIGBgVq/fr0aNmxY7b7Lly8rPDxc+/btU58+fRQfH2+TfMXFxdq8ebMSExO1ZcsWFRcXq0OHDuaOvSeeeMImOW4HWS2vdevWcnJy0uHDhyutnz59Wr/+9a/11VdfSZL576rSjb+nODk5KSIiQtHR0bfsjMXdoUAIAAAAAMB9YOvWrYqOjlZaWlqV5wzDUPfu3RUZGWmz87ECAwN19OjRSjdRPT097/g6trhBT1bby83N1d69e/Xcc8+Zb/pduHBBM2fO1Pbt21VeXq7Q0FBNmzZNHh4edst5rxyl8OYoOSXrZO3QoYNycnL00ksvKSQkRJI0duxYGYahpUuXVrppfSvDhg2zWK478fLLL2vt2rUyDEOPP/64unbtquXLl8swDM2ZM0fp6elau3atLl++rODgYK1fv95uZ5GR1fKOHDmibt266dq1a2rdurUiIyPVs2dPeXl5SZKKioqUnJysuXPn6vDhwzIMQ4mJiXrqqadsnvX69etKTU1VUlKSEhMTdfz4cT300EPq06eP+vTpo2eeeabWFIPIahnVfeCipKREPXr00NGjRyVJzz77rPmc7OLiYv3zn/9UYmKirl+/rr59++qjjz6yS/b7HQVCAAAAAADuI3l5eUpPT9f58+fl7OwsX19ftW/f3jx+zFaioqJ05swZSdLSpUsl6a5v7lR0bVgLWW1rzpw5evfdd1VeXq4jR47I19dXktSvXz+lpKSYizGGYahz585KTk5WvXr17JL1XjlK4c1RckrWyRoTE6PY2NibnuF6J+xVeC8rK9Ps2bO1ZMkSXb16VYZhVPpZMplMMgxDL730kt555x25u7vbJSdZrScpKUkjR45USUmJ+deyu7u7DMPQhQsXJN3o0HJ2dlZMTIxeffVVu2X9oW+//VYJCQlKSkrS3r175ebmph49eigsLEyhoaGVzn+0N7LeneoKhLGxsYqJiZGnp6fi4+PVrVu3Kq87ePCgBg4cqPPnz+v999/XCy+8YLPMdQUFQgAAAAAAANjE559/bh6/17RpU3311Vdq3LixUlNT1bdvX7m5uSkmJkYuLi6aPn26CgsLFRcXp9GjR9s5+d1xlMKbo+SUrJPVZDLpgw8+0LZt21RUVCRJSk1NlWEY1d60rsnGjRstlutu5Ofna82aNdq/f7/y8vJ0/fp1NWnSRB07dlR4eLhatWpl13w/RFbLO3nypObPn6+1a9fq3LlzlZ5zc3NTz549NWnSJD355JN2Slizs2fPKjExUYmJifryyy915coVBQQEqG/fvnr++efl5+dn74hmZL191RUIu3btqoyMDL377rt65ZVXbvrajz76SOPGjdMvfvELrVu3zqo56yIKhAAAAAAAwOI+/vhji13L2iP7yGo7YWFh2rVrl0aNGqV58+aZ1ydPnqxly5Zp7Nixio2NlSTFx8drzJgxeuqpp5SUlGTzrJbgKIU3R8kp2S6rI51BCFQnOztb+fn5KisrU5MmTdSyZUs5OzvbO9ZtKy0t1bZt25SYmKhNmzZpxIgRmjp1qr1jVYusNavu99OKs18zMzPl7e1909eeP39eDz/8sLy8vJSVlWXVnHURBUIAAAAAAGBxFTeD7kXF6DZr36Anq+34+/uruLhY33zzjZo1a2Zer+gkSEhI0NNPPy1JOnfunFq2bOnQNwUdpfDmKDkl22WNjo6WYRiaNm3aXV8jLi5OI0eOrPHmtyV4enrKyclJubm5teY8tJshq+1dvXrVofNXKCoquqszd+2BrJVVVyBs3ry5Lly4oLy8vBp/fV66dEkPPfSQ6tevr/z8fKvmrIscc4A7AAAAAACo1bp161ZtIevatWvas2eP+bGnp6eaN28uZ2dnZWVlmW8eeXh4KCIiwiZnz5HVdi5evChJlc4+KigoUEZGhlxdXRUYGGhef+CBByRJJSUltg35bxXdmrfbaRkfHy9PT0+FhYWZ1yIjI81nLFqLo+SUHCvr22+/fc/XmDt3rvr372/1AqG/v79ycnKUmZmptm3bWvW97hVZrausrEwrVqzQhg0blJGRobNnz8pkMqmgoEBHjx7V8uXL9eqrr+rhhx+2W8aKLnFLsWb3G1mtJyAgQF9++aXS09MVEBBw030HDx6UJD344INWzVNX0UEIAAAAAABsoqysTIMGDdL27dvVo0cPTZ06VV27dq205+DBg4qOjlZSUpKeeeYZrV692i4j0chqHY8++qhyc3P11VdfqU2bNpL+cy5h9+7dtWHDBvPe48ePq3PnzvL09FR2drbNs1Z0DxUUFNzWfn9/fzk5OenEiRPWDfYjjpJTcqyslmCrbsdly5Zp8uTJGj16dKXRvbURWa0nMzNTgwYNUlZWlkym/9zyr+jc2r9/v5555hk1bNhQ77//vsLDw+2S80474Su63m+2bs1ueLJaNtv06dP12GOPqW3btsrMzNQLL7ygp59+WuvWrZOLi0uV1128eFH9+/fXvn37NHToUC1dutRimXADHYQAAAAAAMAmFi1apB07dmjIkCF6//33q93TqVMnrVy5UmPHjlV8fLwWLVqkSZMm2TgpWa0lKChI69atU2xsrFasWKHS0lK99957MgxDvXv3rrR32bJlkm4UFW0hJyenSiHSZDJp165dlW62Vyc7O1sXLlyQq6urNSNKcpyckmNldWSjR4/WuXPnNG/ePBmGoVGjRql169b2jlUtslpHUVGRBgwYoJycHLVq1UqTJ09WQECAunTpYt7TqlUrPf/88/rss880cuRI7dy5U4888ojNsy5evFg5OTmaP3++rl+/rnr16qlt27by8/OTi4uLsrOz9e2336q0tFROTk761a9+JTc3N5vnJKtlmUwmzZkzx/y4QYMGcnZ21u7duxUREaF//OMf5ucuXryoVatWafHixcrMzJSrq6tee+01m2WtS+ggBAAAAAAANhEUFKTDhw9r3759atWqVY17K7rH2rRpo7S0NBsl/A+yWseePXsUGhoqSWratKnKy8uVn58vd3d3HTp0SN7e3kpJSVFUVJT27t0r6cZZcOPGjbN6tpiYGM2dO/euX28ymdSlSxclJydbMFVVjpJTcqys1mCrDsIXX3xRknTo0CGdPn1aktSoUSN5eXnV2Cl86NAhq+aqDlmtY+7cuYqOjlanTp20ceNG84jm6s5+GzNmjOLj4/XKK69o4cKFNs96/vx5BQcH6/vvv9crr7yit956S35+fpX25OXl6Z133tGf//xnBQQEKCkpyS7nKJLVMpKTk3Xs2DHzf5mZmTp58qTKy8slSY8//rh2795daf/gwYMlSQ0bNtTSpUv1q1/9yuo56yI6CAEAAAAAgE1UjAn09/e/5d6Km1r2GC0pkdVagoKCtHDhQkVGRio3N1fSjRvuixcvNp/TduDAAXPxMiQkRKNHj7ZJtopzGytkZ2fLMIxKazdjGIZatGhh8TOgquMoOSXHyurIkpKSqqyVlJTUeH7nnYwitCSyWse6detkGIZiYmLMxcGbef311xUfH6+tW7faKF1lcXFxOnXqlF577TXNnj272j1NmzZVXFycGjZsqIULF2rBggVWPxOvOmS1jJ49e6pnz56V1q5evarMzEwdO3ZMxcXFVV7j5+en/v37a/z48VUKnbAcOggBAAAAAIBNtGjRQoWFhdq5c6fatWtX49709HQFBwfL29tb3333nY0S/gdZrevs2bPavXu3XFxcFBAQIF9fX/NziYmJSkpKUkhIiAYOHCgnJye7ZKyu86Y2cpSckmNltQRbdRCmpqbe1euCg4MtnOTWyGodzZo106VLl5Sfn1/pLLfqfuZKS0vVtGlT1a9fX/n5+TbP2rFjR2VnZ+ubb75Rs2bNatx7+vRpPfbYY2rdurW5q9yWyHrvbnbWYU3Ky8vt9md/XUMHIQAAAAAAsImAgAB98cUXmjVrlj755JOb3jAymUyaNWuWDMNQYGCgjVPeQFbr8vHxUb9+/ap9rk+fPurTp4+NE1U1dOhQu3UD3QlHySk5VlZHYo+C1N0iq3VUFAWLiork4+NT496K7m17nZVXMa71VjklmTvLc3JyrJrpZsh67x5++GGFhoaqb9++evbZZ9WoUaNbvobioO3wnQYAAAAAADYxYcIEmUwmbdq0SQMGDKj2U+tpaWnq37+/Nm/eLEmaOHGirWNKIiukP/3pT1q6dKm9Y9ySo+SUHCtrbbVkyZIqY1djY2Pv6axHayGr7XTo0EGStHLlylvurTjT09qdrTfTuHFjSdL+/ftvubdiz+0UlayBrPduypQpOn36tCIiIvTwww9r4MCB+uCDD3Tq1CmrvzdujRGjAAAAAADAZubPn2/uYpMkDw8P+fn5yTAMnTx5UkVFRTKZbtyqiIqK0htvvEFWB80aGBioY8eOyTAMFRQUSJLCw8Pv+DqGYWj9+vWWjnfbcnNztXfvXj333HOqX7++JOnChQuaOXOmtm/frvLycoWGhmratGny8PAg532W9V5YY8ToT37yE125ckWnT582d4DV1tGtZLWdVatWadSoUWrQoIEWLFig4cOHS6r6NWRmZqpnz54qKCjQggULFBERYfOsv/nNb/Tpp58qMDBQ69evV8OGDavdd/nyZYWHh2vfvn3q06eP4uPjbZyUrJZUXFyszZs3KzExUVu2bFFxcbE6dOig3r17KywsTE888YRNcqAyCoQAAAAAAMCmtm7dqujoaKWlpVV5zjAMde/eXZGRkbVivBtZ715gYKCOHj1a6ea0p6fnHV/Hnjfo58yZo3fffVfl5eU6cuSI+azEfv36KSUlxVx0NQxDnTt3VnJysurVs/2JPo6S09Gy3itrFAg7dOignJwcvfTSSwoJCZEkjR07VoZhaOnSpebv3+0YNmyYxXJVh6y29fLLL2vt2rUyDEOPP/64unbtquXLl8swDM2ZM0fp6elau3atLl++rODgYK1fv94uoxyPHDmibt266dq1a2rdurUiIyPVs2dPeXl5SboxJjU5OVlz587V4cOHZRiGEhMT9dRTT5H1Psl6/fp1paamKikpSYmJiTp+/Lgeeugh84jxZ555xvzhEVgXBUIAAAAAAGAXeXl5Sk9P1/nz5+Xs7CxfX1+1b9/ePCarNiHrnYuKitKZM2ckyTxW8qOPPrqra1V0w9jS559/bu6uadq0qb766is1btxYqamp6tu3r9zc3BQTEyMXFxdNnz5dhYWFiouL0+jRo8l5H2S1BGsUCGNiYhQbG2uRsxytXXgnq22VlZVp9uzZWrJkia5evSrDMCoV3E0mkwzD0EsvvaR33nlH7u7udskpSUlJSRo5cqRKSkrM33N3d3cZhqELFy5IunFurrOzs2JiYvTqq6+S9T7L+kPffvutEhISlJSUpL1798rNzU09evRQWFiYQkNDb+tcRdwdCoQAAAAAAADAj4SFhWnXrl0aNWqU5s2bZ16fPHmyli1bprFjx5rPLIuPj9eYMWP01FNPKSkpiZz3QVZLsEaB0GQy6YMPPtC2bdtUVFQkSUpNTZVhGOrWrdsdXWvjxo0Wy1UdstpHfn6+1qxZo/379ysvL0/Xr19XkyZN1LFjR4WHh6tVq1Z2zVfh5MmTmj9/vtauXatz585Ves7NzU09e/bUpEmT9OSTT9op4X+Q1XbOnj2rxMREJSYm6ssvv9SVK1cUEBCgvn376vnnn5efn5+9I95XKBACAAAAAADA4j7++GOLXcseI/v8/f1VXFysb775Rs2aNTOvd+3aVRkZGUpISNDTTz8tSTp37pxatmwpLy8vZWVlkfM+yGoJ1igQVseRzsojK6qTnZ2t/Px8lZWVqUmTJmrZsqWcnZ3tHataZLWd0tJSbdu2TYmJidq0aZNGjBihqVOn2jvWfcUxB3gDAAAAAACgVqs4v+teVIzEs0eB8OLFi5JUabRZQUGBMjIy5OrqqsDAQPP6Aw88IEkqKSmxbUg5Tk7JsbI6ksjIyHv+WYuLi9PIkSPl7e1toVTVI6t1eHp6ysnJSbm5uQ55dpu/v7/8/f119erVWp+frLbj6uqq3r17q3fv3pJk7u6F5VAgBAAAAAAAgMV169at2pvr165d0549e8yPPT091bx5czk7OysrK8vcrePh4aGIiAjVq2ef21c+Pj7Kzc3ViRMn1KZNG0nS1q1bZTKZ1KVLl0o3W0+dOiVJatSoETnvk6wVHbC3W5yOj4+Xp6enwsLCzGuRkZHy9fW1Sr4fevvtt+/5GnPnzlX//v2tXsgiq3X4+/srJydHmZmZatu2rVXfy1LKysq0YsUKbdiwQRkZGTp79qxMJpMKCgp09OhRLV++XK+++qoefvhhe0clq4VVjJK2FLoK7x4FQgAAAAAAAFhcQkJClbWysjINGjRIktSjRw9NnTpVXbt2rbTn4MGDio6OVlJSkg4cOKDVq1fbJO+PBQUFad26dYqNjdWKFStUWlqq9957T4ZhmLsZKixbtkyS9Oijj5KzBo6UdezYsXJycrrtAmFkZKScnJx04sSJSmuOwmRynFOoyFrVxIkTNXnyZK1YsaLS+Z61VWZmpgYNGqSsrKxK36OKD5WUlJRo6dKl+tvf/qb3339f4eHh9opKViuIiYm5o+7cimkCN1unQHj3KBACAAAAAADAJhYtWqQdO3ZoyJAhev/996vd06lTJ61cuVJjx45VfHy8Fi1apEmTJtk4qTR+/HitW7dOq1evVmpqqsrLy5Wfny93d3cNHTpUkpSSkqKoqCjt3btXhmFo4MCB5HTQrDk5OcrOzq60ZjKZtGvXrlsWebKzs3XhwgW5urpaMyJwU6NHj9a5c+c0b948GYahUaNGqXXr1vaOVa2ioiINGDBAOTk5atWqlSZPnqyAgAB16dLFvKdVq1Z6/vnn9dlnn2nkyJHauXOnHnnkEbLeJ1kXL16snJwczZ8/X9evX1e9evXUtm1b+fn5ycXFRdnZ2fr2229VWloqJycn/epXv5Kbm5vNc9YFFAgBAAAAAABgE6tWrZJ0e+PApkyZoo8//ljx8fF2KRAGBQVp4cKFioyMVG5urqQb4y4XL15sHhd44MABpaWlSZJCQkI0evRocjpo1g8//FBz5841P67oVvnhyNCamEwmtW/f3irZgFt58cUXJUkPPvigli1bpmXLlqlRo0by8vKSs7PzTV936NAhW0U0+9Of/qScnBx16tRJGzduNJ83+kMeHh5avny5XFxcFB8frz/84Q9auHAhWe+TrOHh4QoODlZ5ebkiIiL01ltvyc/Pr9KevLw8vfPOO/rzn/+s7OxsJSUlOeQ5irUdBUIAAAAAAADYRMX4RX9//1vurbhZ+OOuLlsaMWKEwsPDtXv3brm4uCggIKDSmXKPPPKIRowYoZCQEA0cOFBOTk7kdNCsFWdhVsjOzpZhGJXWbsYwDLVo0cLi52oBtyspKanKWklJiUpKSm76mjsZ8WhJ69atk2EYiomJqbaI9UOvv/664uPjtXXrVhulq4ys1hEXF6dTp07ptdde0+zZs6vd07RpU8XFxalhw4ZauHChFixYwChRKzCKi4sdZ2gzAAAAAAAAHFaLFi1UWFionTt3ql27djXuTU9PV3BwsLy9vfXdd9/ZKCFwg6enpwzDUGFhob2j2ESTJk20a9cuPfbYY/aOcktkrSo1NfWuXhccHGzhJLfWrFkzXbp0Sfn5+XJxcTGvV/czV1paqqZNm6p+/frKz88n632StWPHjsrOztY333yjZs2a1bj39OnTeuyxx9S6dWvt3bvXRgnrDjoIAQAAAAAAYBMBAQH64osvNGvWLH3yySc37WAxmUyaNWuWDMNQYGCgjVMC0tChQ+3WYQXcKXsU+u5WRfGqqKhIPj4+Ne6tGEVsr/PnyGodp0+flqRb5pRkHj+dk5Nj1Ux1FQVCAAAAAAAA2MSECROUnJysTZs2acCAAZoxY0aVAmBaWppmzZqlHTt2yDAMTZw40eq5AgMDdezYMRmGoYKCAkk3zki6U4ZhaP369ZaOZ+YoOSXHylqdP/3pTzZ/T+B2LFmyRMXFxZXGLcbGxsowDEVGRtox2e3p0KGDUlNTtXLlSo0fP77GvcnJyZJkt25RslpH48aNlZeXp/379ysoKKjGvfv375d047xaWB4FQgAAAAAAANhEjx49NGPGDHMBsGfPnvLw8JCfn58Mw9DJkydVVFQkk+nGiTgzZ85U9+7dbZKt4j0rpKSk3PE1bNFx5ig5JcfKejO5ubnau3evnnvuOdWvX1+SdOHCBc2cOVPbt29XeXm5QkNDNW3aNHl4eNg1K+qGWbNm6cqVK3r99dfNHWAxMTEOUyB8+eWXlZKSolmzZsnLy0vDhw+vdl9mZqZmz54twzD00ksv2TjlDWS1jpCQEH366ad6++23tX79ejVs2LDafZcvX9bbb78twzBuWUjE3aFACAAAAAAAAJt566239MQTTyg6OlppaWkqKipSUVGR+XnDMBQSEqLIyEibjc3r16+fzpw5U2ltyZIlNnnvO+EoOSXHynozc+bM0bvvvqvy8nIdOXJEvr6+kqRhw4YpJSXFXABdunSpdu/ereTkZNWrx+1WWJevr69ycnL05ptvKiQkpNJz8fHxVQrzNRk2bJil493SkCFDtGHDBq1du1bjx4/XH//4R3Xt2tX8/B/+8Aelp6dr7dq1unz5soKDgzVixAib5ySr9UyZMkVr167Vvn379Itf/EKRkZHq2bOnvLy8JN0Yk5qcnKy5c+fq8OHDMgxDr732ml2y3u+M4uLi2/8dAwAAAAAAALCQvLw8paen6/z583J2dpavr6/at2+vxo0b2zsa6rjPP/9cERERkqSmTZvqq6++UuPGjZWamqq+ffvKzc1NMTExcnFx0fTp01VYWKi4uDiNHj3azsnvTpMmTbRr1y67jRy8E3U9a0xMjHmk6L0qLCy890B3oaysTLNnz9aSJUt09epVGYZhLmxW/O+KDrd33nlH7u7udslJVutJSkrSyJEjVVJSYv617O7uLsMwdOHCBUk3utCdnZ0VExOjV1991W5Z72cUCAEAAAAAAFCnffzxxxa7ljU7chwlp+RYWasTFhamXbt2adSoUZo3b555ffLkyVq2bJnGjh2r2NhYSTe6tsaMGaOnnnpKSUlJNs9qCXW96GYt1shqMpn0wQcfaNu2bebu69TUVBmGoW7dut3RtTZu3GixXHcjPz9fa9as0f79+5WXl6fr16+rSZMm6tixo8LDw9WqVSu75vshslreyZMnNX/+fK1du1bnzp2r9Jybm5t69uypSZMm6cknn7RTwvsfBUIAAAAAAADUaZ6envfcjVPRmWHNjhxHySk5Vtbq+Pv7q7i4WN98842aNWtmXu/atasyMjKUkJCgp59+WpJ07tw5tWzZUl5eXsrKyrJ5Vkuo60U3a7FV1oqfN3t1BAL3Kjs7W/n5+SorK1OTJk3UsmVLOTs72zvWfY+h2AAAAAAAAKjTunXrVm0x69q1a9qzZ4/5saenp5o3by5nZ2dlZWWZb8Z7eHgoIiLC6ufPOUpOR8tanYsXL0qSfHx8zGsFBQXKyMiQq6urAgMDzesPPPCAJKmkpMS2IYF/i4yMvOeCfFxcnEaOHClvb28Lpaqep6ennJyclJubq/r161v1ve4VWW3H399f/v7+unr1qkPmd1QUCAEAAAAAAFCnJSQkVFkrKyvToEGDJEk9evTQ1KlT1bVr10p7Dh48qOjoaCUlJenAgQNavXo1OR0wa3V8fHyUm5urEydOqE2bNpKkrVu3ymQyqUuXLpVuYJ86dUqS1KhRI7tkrRjnerujWOPj4+Xp6amwsDDzWmRkpHx9fa2S74fIah1vv/32PV9j7ty56t+/v9ULhP7+/srJyVFmZqbatm1r1fe6V2S1rrKyMq1YsUIbNmxQRkaGzp49K5PJpIKCAh09elTLly/Xq6++qocfftjeUe9bTvYOAAAAAAAAANQ2ixYt0o4dOzRkyBCtWbOmSiFLkjp16qSVK1dq2LBh2r59uxYtWkTOGjhS1qCgIEkynzNYWlqq9957T4ZhqHfv3pX2Llu2TJL06KOP2jbkv40dO1bjx4+/7f2RkZEaN25clTVrF4YkstZmJpNtTiKbOHGiTCaTVqxYYZP3uxdktZ7MzEwFBARoypQp2r59u3Jzc3X9+nXzr8OSkhItXbpUTz/9tDZs2GDntPcvOggBAAAAAACAH1m1apUkaerUqbfcO2XKFH388ceKj4/XpEmTrB2tEkfJKTlW1vHjx2vdunVavXq1UlNTVV5ervz8fLm7u2vo0KGSpJSUFEVFRWnv3r0yDEMDBw60SbacnBxlZ2dXWjOZTNq1a9ctizzZ2dm6cOGCXF1drRnRjKz4sdGjR+vcuXOaN2+eDMPQqFGj1Lp1a3vHqhZZraOoqEgDBgxQTk6OWrVqpcmTJysgIEBdunQx72nVqpWef/55ffbZZxo5cqR27typRx55xI6p709GcXGxbT4aAAAAAAAAADiIBx98UKWlpcrPz5eLi0uNe69duyYfHx81aNBAubm5Nkp4g6PklBwrqyT99a9/VWRkpK5cuSLpxgjRP/zhD+YxqYsXL9b06dMlSSEhIfrf//1fm5yZGBMTo7lz59716yvGpCYnJ1swVfXI6jiaNGmiXbt26bHHHrPq+7z44ouSpEOHDun06dOSbvxseXl5ydnZ+aavO3TokFVzVYes1jF37lxFR0erU6dO2rhxo/kcV09PTxmGYT6LVpLGjBmj+Ph4vfLKK1q4cKHNs97v6CAEAAAAAAAAfsTNzU2lpaU6cuSI2rVrV+PejIwMSfY5g85RckqOlVWSRowYofDwcO3evVsuLi4KCAiodJ7cI488ohEjRigkJEQDBw6Uk5NtTnPy9PRU8+bNzY+zs7NlGEaltZsxDEMtWrQwj061NrLix5KSkqqslZSUqKSk5KavMQzDmpFuiqzWsW7dOhmGoZiYGHNx8GZef/11xcfHa+vWrTZKV7fQQQgAAAAAAAD8yODBg/XFF18oNDRUn3zyyU1vpJpMJg0ZMkRbtmxRr169zGM0yVmVI2V1JNV13dRWZK29bNVBmJqaelevCw4OtnCSWyOrdTRr1kyXLl2q0k1e3c9caWmpmjZtqvr16ys/P9/mWe93dBACAAAAAAAAPzJhwgQlJydr06ZNGjBggGbMmKHAwMBKe9LS0jRr1izt2LFDhmFo4sSJ5LxPsjqSoUOH2q0T6E6RFfYoSN0tslpHRVGwqKhIPj4+Ne6tGDHt5uZm9Vx1ER2EAAAAAAAAQDXmz5+vWbNmmYsEHh4e8vPzk2EYOnnypIqKimQy3bi1FhUVpTfeeIOcDpg1MDBQx44dk2EYKigokCSFh4ff8XUMw9D69estHQ+wCWt0EC5ZskTFxcWaOnWqeS02NlaGYSgyMtJi72MJZLWd8PBwpaam6n/+5380fvx483p1HYQrVqzQm2++qaCgIG3evNkOae9vFAgBAAAAAACAm9i6dauio6OVlpZW5TnDMNS9e3dFRkbavXvDUXJKtS9rYGCgjh49WunGtKen5x1fx97jKHNzc7V3714999xzql+/viTpwoULmjlzprZv367y8nKFhoZq2rRp8vDwsFtOstZO1igQ/uQnP9GVK1d0+vRpcwdYbR3dSlbbWbVqlUaNGqUGDRpowYIFGj58uKSqX0NmZqZ69uypgoICLViwQBEREXZMfX+iQAgAAAAAAADcQl5entLT03X+/Hk5OzvL19dX7du3V+PGje0drRJHySnVnqxRUVE6c+aMJGnp0qWSpI8++uiurlVxo9vW5syZo3fffVfl5eU6cuSIfH19JUn9+vVTSkqKuSvTMAx17txZycnJqlfPPqdPkbV2skaBsEOHDsrJydFLL72kkJAQSdLYsWNlGIaWLl1q/v7djmHDhlksV3XIalsvv/yy1q5dK8Mw9Pjjj6tr165avny5DMPQnDlzlJ6errVr1+ry5csKDg7W+vXr5eTkZJes9zMKhAAAAAAAAADgoD7//HNzZ03Tpk311VdfqXHjxkpNTVXfvn3l5uammJgYubi4aPr06SosLFRcXJxGjx5N1vskqyVYo0AYExNjHn15r6zdGUdW2yorK9Ps2bO1ZMkSXb16VYZhVCq4m0wmGYahl156Se+8847c3d3tkvN+55gfZwAAAAAAAAAAC/j4448tdi17dONUdN2MGjVK8+bNM6+vXbtWkjRixAi98sorkiRnZ2eNGTNGq1evtkshi6x1y9SpU+Xj46Nt27apqKhIkpSamirDMNStWzc7p6uMrLZVr149RUVFacKECVqzZo3279+vvLw8Xb9+XU2aNFHHjh0VHh6uVq1a2TvqfY0OQgAAAAAAAAB1VsW5V/eiotvFHt04/v7+Ki4u1jfffKNmzZqZ17t27aqMjAwlJCTo6aefliSdO3dOLVu2lJeXl7Kyssh6n2S1BGt0EFbHkc7KIyvud3QQAgAAAAAAAKizunXrVm2B8Nq1a9qzZ4/5saenp5o3by5nZ2dlZWWZb8R7eHgoIiLCbmfPXbx4UZLk4+NjXisoKFBGRoZcXV0VGBhoXn/ggQckSSUlJbYN+W9kRWRk5D0X5OPi4jRy5Eh5e3tbKFX1yGodnp6ecnJyUm5ururXr2/V90LNKBACAAAAAAAAqLMSEhKqrJWVlWnQoEGSpB49emjq1Knq2rVrpT0HDx5UdHS0kpKSdODAAa1evdomeX/Mx8dHubm5OnHihNq0aSNJ2rp1q0wmk7p06VLpBvypU6ckSY0aNSLrfZS1Ykzu7Y64jY+Pl6enp8LCwsxrkZGR8vX1tUq+H3r77bfv+Rpz585V//79rV7IIqt1+Pv7KycnR5mZmWrbtq1V3ws1c7J3AAAAAAAAAACoTRYtWqQdO3ZoyJAhWrNmTZXioCR16tRJK1eu1LBhw7R9+3YtWrTIDkmloKAgSVJsbKwkqbS0VO+9954Mw1Dv3r0r7V22bJkk6dFHH7VtyH8jq3WMHTtW48ePv+39kZGRGjduXJU1axeGLMVkcpxT08ha1cSJE2UymbRixQqbvB9ujg5CAAAAAAAAAPiBVatWSZKmTp16y71TpkzRxx9/rPj4eE2aNMna0aoYP3681q1bp9WrVys1NVXl5eXKz8+Xu7u7hg4dKklKSUlRVFSU9u7dK8MwNHDgQJvnJKvl5OTkKDs7u9KayWTSrl27blnkyc7O1oULF+Tq6mrNiMBNjR49WufOndO8efNkGIZGjRql1q1b2ztWnUSBEAAAAAAAAAB+4MSJE5JujMK7FT8/P0mqUrCxlaCgIC1cuFCRkZHKzc2VdGPU5eLFi80dYQcOHFBaWpokKSQkRKNHjyarA2f98MMPNXfuXPPjirPnfjgytCYmk0nt27e3SjbgVl588UVJ0oMPPqhly5Zp2bJlatSokby8vOTs7HzT1x06dMhWEesMCoQAAAAAAAAA8ANubm4qLS3VkSNH1K5duxr3ZmRkSLLf+XOSNGLECIWHh2v37t1ycXFRQEBApfPkHnnkEY0YMUIhISEaOHCgnJzsd/IUWe+dp6enmjdvbn6cnZ0twzAqrd2MYRhq0aKFeXQqYGtJSUlV1kpKSlRSUnLT11QUwWFZRnFxseMMwQUAAAAAAAAAKxs8eLC++OILhYaG6pNPPrnpzWmTyaQhQ4Zoy5Yt6tWrl3k0KWBLnp6eMgxDhYWF9o5iE02aNNGuXbv02GOP2TvKLZG1qtTU1Lt6XXBwsIWTgA5CAAAAAAAAAPiBCRMmKDk5WZs2bdKAAQM0Y8YMBQYGVtqTlpamWbNmaceOHTIMQxMnTrRTWtR1Q4cOpcMKDoNCX+1BgRAAAAAAAAAAfqBHjx6aMWOGuQDYs2dPeXh4yM/PT4Zh6OTJkyoqKpLJdGM428yZM9W9e3er5woMDNSxY8dkGIYKCgokSeHh4Xd8HcMwtH79ekvHq4SstvOnP/3J5u8J3I4lS5aouLhYU6dONa/FxsbKMAxFRkbaMRkkCoQAAAAAAAAAUMVbb72lJ554QtHR0UpLS1NRUZGKiorMzxuGoZCQEEVGRtq0I6aiKFkhJSXljq9hq24zstpWbm6u9u7dq+eee07169eXJF24cEEzZ87U9u3bVV5ertDQUE2bNk0eHh52zYq6YdasWbpy5Ypef/11ubm5SZJiYmIoENYSFAgBAAAAAAAAoBq//OUv9ctf/lJ5eXlKT0/X+fPn5ezsLF9fX7Vv316NGze2aZ5+/frpzJkzldaWLFli0wy3i6y2NWfOHL377rsqLy/XkSNH5OvrK0kaNmyYUlJSzAXQpUuXavfu3UpOTla9epQHYF2+vr7KycnRm2++qZCQkErPxcfHVynM12TYsGGWjlfnGcXFxbf//wAAAAAAAAAAAKg1Pv/8c0VEREiSmjZtqq+++kqNGzdWamqq+vbtKzc3N8XExMjFxUXTp09XYWGh4uLiNHr0aDsnvztNmjTRrl279Nhjj9k7yi3V9awxMTHmkaL3qrCw8N4DoRI+IgAAAAAAAAAADuDjjz+22LWs3Y1DVttZvny5DMPQqFGjNG/ePPP62rVrJUkjRozQK6+8IklydnbWmDFjtHr1aoctEMJxTJ06VT4+Ptq2bZt5RHNqaqoMw1C3bt3snA50EAIAAAAAAACAA/D09LznThyTySTDMKzejUNW2/H391dxcbG++eYbNWvWzLzetWtXZWRkKCEhQU8//bQk6dy5c2rZsqW8vLyUlZVl86yWUNe78qzFVlkrft7oCLQ/OggBAAAAAAAAwAF069at2kLWtWvXtGfPHvNjT09PNW/eXM7OzsrKyjLfiPfw8FBERIRNzp4jq+1cvHhRkuTj42NeKygoUEZGhlxdXRUYGGhef+CBByRJJSUltg0J/FtkZOQ9F+Tj4uI0cuRIeXt7WyhV3USBEAAAAAAAAAAcQEJCQpW1srIyDRo0SJLUo0cPTZ06VV27dq205+DBg4qOjlZSUpIOHDig1atXk9VBs1bHx8dHubm5OnHihNq0aSNJ2rp1q0wmk7p06aL69eub9546dUqS1KhRI7tkrRjnerujWOPj4+Xp6amwsDDzWmRkpHx9fa2S74fIah1vv/32PV9j7ty56t+/PwXCe8SIUQAAAAAAAABwUPPnz9fs2bP1wgsv6P33369x79ixYxUfH68ZM2Zo0qRJNkr4H2S1jpdfflnr1q3ToEGDtGLFCpWWlqpXr146ePCg5syZowkTJpj3Tps2TUuWLNHPf/5zbdmyxeZZPT095eTkpIKCgtva7+/vLycnJ504ccK6wapB1trLkUa31mYUCAEAAAAAAADAQQUFBenw4cPat2+fWrVqVePe48ePq3PnzmrTpo3S0tJslPA/yGode/bsUWhoqCSpadOmKi8vV35+vtzd3XXo0CF5e3srJSVFUVFR2rt3ryQpOjpa48aNs3q2nJwcZWdnmx+HhYXJMAwlJCTIZKq5NJGdna1x48bJ1dVVZ86csXZUsjoQCoSWwYhRAAAAAAAAAHBQFR1A/v7+t9zr5+cnSZUKC7ZEVusICgrSwoULFRkZqdzcXEk3RoguXrzYPILxwIED5uJlSEiIRo8ebZNsH374oebOnWt+XHH23A9HW9bEZDKpffv2Vsn2Y2RFXUOBEAAAAAAAAAAclJubm0pLS3XkyBG1a9euxr0ZGRmS7Hf+HFmtZ8SIEQoPD9fu3bvl4uKigICASufJPfLIIxoxYoRCQkI0cOBAOTk52SSXp6enmjdvbn6cnZ0twzAqrd2MYRhq0aKFYmNjrRnRjKyoaxgxCgAAAAAAAAAOavDgwfriiy8UGhqqTz75xNxJ9GMmk0lDhgzRli1b1KtXL61atcrGScmKG4UtwzBUWFho7yi3RNbaixGjlmGbjwkAAAAAAAAAACxuwoQJMplM2rRpkwYMGGA+Y+6H0tLS1L9/f23evFmSNHHiRFvHlERWSEOHDtXQoUPtHeO2kBX3OzoIAQAAAAAAAMCBzZ8/X7NmzTJ3uXl4eMjPz0+GYejkyZMqKiqSyXTjNnBUVJTeeOMNsjpo1sDAQB07dkyGYaigoECSFB4efsfXMQxD69evt3Q8wCboILQMCoQAAAAAAAAA4OC2bt2q6OhopaWlVXnOMAx1795dkZGRCg4OtkO6ysh69wIDA3X06NFK4yQ9PT3v+Dr2HkeZm5urvXv36rnnnlP9+vUlSRcuXNDMmTO1fft2lZeXKzQ0VNOmTZOHh4fdcpK1dqJAaBkUCAEAAAAAAADgPpGXl6f09HSdP39ezs7O8vX1Vfv27dW4cWN7R6uCrHcuKipKZ86ckSQtXbpUkvTRRx/d1bWGDx9usVx3Ys6cOXr33XdVXl6uI0eOyNfXV5LUr18/paSkmLsyDcNQ586dlZycrHr16pH1Psp6rygQWgYFQgAAAAAAAAAAYHWff/65IiIiJElNmzbVV199pcaNGys1NVV9+/aVm5ubYmJi5OLiounTp6uwsFBxcXEaPXo0We+TrJZAgdAyHLM8DAAAAAAAAABAHfPxxx9b7FrDhg2z2LVu1/Lly2UYhkaNGqV58+aZ19euXStJGjFihF555RVJkrOzs8aMGaPVq1fbpZBFVtzvKBACAAAAAAAAAOAAxo4dK8Mw7ukaJpNJhmHYpUD49ddfS5LefPPNSuspKSkyDEP9+/c3r/Xq1UuS9O2339ou4A+QFfc7CoQAAAAAAAAAADiAbt26VVsgvHbtmvbs2WN+7OnpqebNm8vZ2VlZWVkqLCyUJHl4eCgiIsJuZ89dvHhRkuTj42NeKygoUEZGhlxdXRUYGGhef+CBByRJJSUltg35b2TF/Y4CIQAAAAAAAAAADiAhIaHKWllZmQYNGiRJ6tGjh6ZOnaquXbtW2nPw4EFFR0crKSlJBw4c0OrVq22S98d8fHyUm5urEydOqE2bNpKkrVu3ymQyqUuXLqpfv75576lTpyRJjRo1Iut9lLViTO7tdrDGx8fL09NTYWFh5rXIyEj5+vpaJV9d4mTvAAAAAAAAAAAA4O4sWrRIO3bs0JAhQ7RmzZoqxUFJ6tSpk1auXKlhw4Zp+/btWrRokR2SSkFBQZKk2NhYSVJpaanee+89GYah3r17V9q7bNkySdKjjz5q25D/RlbrGDt2rMaPH3/b+yMjIzVu3Lgqa97e3paOVucYxcXFJnuHAAAAAAAAAAAAdy4oKEiHDx/Wvn371KpVqxr3Hj9+XJ07d1abNm2UlpZmo4T/sWfPHoWGhkqSmjZtqvLycuXn58vd3V2HDh2St7e3UlJSFBUVpb1790qSoqOjqxSIyOo4WXNycpSdnW1+HBYWJsMwlJCQIJOp5vJUdna2xo0bJ1dXV505c8baUescRowCAAAAAAAAAOCgTpw4IUny9/e/5V4/Pz9JqlSwsaWgoCAtXLhQkZGRys3NlXRj1OXixYvNHWEHDhwwFy9DQkI0evRosjpw1g8//FBz5841P644Q/OHI0NrYjKZ1L59e6tkq+voIAQAAAAAAAAAwEG1aNFChYWF2rlzp9q1a1fj3vT0dAUHB8vb21vfffedjRJWdfbsWe3evVsuLi4KCAiodJ5cYmKikpKSFBISooEDB8rJyb4npZH13ixZskRLly41P87OzpZhGGrevPktX2sYhlq0aKHY2Fg9/vjj1oxZJ1EgBAAAAAAAAADAQQ0ePFhffPGFQkND9cknn5g7tH7MZDJpyJAh2rJli3r16qVVq1bZOCkgeXp6yjAMFRYW2jtKnWffcjYAAAAAAAAAALhrEyZMkMlk0qZNmzRgwADzGXM/lJaWpv79+2vz5s2SpIkTJ9o6JiBJGjp0qIYOHWrvGBAdhAAAAAAAAAAAOLT58+dr1qxZ5u5BDw8P+fn5yTAMnTx5UkVFRTKZbpQCoqKi9MYbb1g9U2BgoI4dOybDMFRQUCBJCg8Pv+PrGIah9evXWzpeJWRFXVTP3gEAAAAAAAAAAMDde+utt/TEE08oOjpaaWlpKioqUlFRkfl5wzAUEhKiyMhIBQcH2yxXRVGyQkpKyh1f42YjUy2NrLaVm5urvXv36rnnnlP9+vUlSRcuXNDMmTO1fft2lZeXKzQ0VNOmTZOHh4dds96vKBACAAAAAAAAAODgfvnLX+qXv/yl8vLylJ6ervPnz8vZ2Vm+vr5q3769GjdubNM8/fr105kzZyqtLVmyxKYZbhdZbWvOnDl69913VV5eriNHjsjX11eSNGzYMKWkpJgLoEuXLtXu3buVnJysevUoZ1kaI0YBAAAAAAAAAABgdZ9//rkiIiIkSU2bNtVXX32lxo0bKzU1VX379pWbm5tiYmLk4uKi6dOnq7CwUHFxcRo9erSdk99/KLkCAAAAAAAAAACL+vjjjy12rWHDhlnsWtUhq+0sX75chmFo1KhRmjdvnnl97dq1kqQRI0bolVdekSQ5OztrzJgxWr16NQVCK6CDEAAAAAAAAAAAWJSnp+c9n3NnMplkGIYKCwstE+omyGo7/v7+Ki4u1jfffKNmzZqZ17t27aqMjAwlJCTo6aefliSdO3dOLVu2lJeXl7Kysmye9X5HByEAAAAAAAAAALCobt26VVvIunbtmvbs2WN+7OnpqebNm8vZ2VlZWVnmopWHh4ciIiJscvYcWW3n4sWLkiQfHx/zWkFBgTIyMuTq6qrAwEDz+gMPPCBJKikpsW3IOoICIQAAAAAAAAAAsKiEhIQqa2VlZRo0aJAkqUePHpo6daq6du1aac/BgwcVHR2tpKQkHThwQKtXryarg2atjo+Pj3Jzc3XixAm1adNGkrR161aZTCZ16dJF9evXN+89deqUJKlRo0Z2yXq/c7J3AAAAAAAAAAAAcP9btGiRduzYoSFDhmjNmjVViliS1KlTJ61cuVLDhg3T9u3btWjRIjskJau1BAUFSZJiY2MlSaWlpXrvvfdkGIZ69+5dae+yZcskSY8++qhtQ9YRnEEIAAAAAAAAAACsLigoSIcPH9a+ffvUqlWrGvceP35cnTt3Vps2bZSWlmajhP9BVuvYs2ePQkNDJUlNmzZVeXm58vPz5e7urkOHDsnb21spKSmKiorS3r17JUnR0dEaN26czbPe7+ggBAAAAAAAAAAAVnfixAlJkr+//y33+vn5SZKys7OtGemmyGodQUFBWrhwoVxdXZWbm6v8/Hw1atRIixcvlre3tyTpwIEDSktLk8lkUvfu3TV69Gi7ZL3fcQYhAAAAAAAAAACwOjc3N5WWlurIkSNq165djXszMjIk2e/8ObJaz4gRIxQeHq7du3fLxcVFAQEB8vX1NT//yCOPaMSIEQoJCdHAgQPl5ESvmzXwXQUAAAAAAAAAAFYXEBAgSZo1a5ZMppuffmYymTRr1iwZhqHAwEBbxauErNbl4+Ojfv36qXfv3pWKg5LUp08fLVq0SIMHD6Y4aEV8ZwEAAAAAAAAAgNVNmDBBJpNJmzZt0oABA8xnzP1QWlqa+vfvr82bN0uSJk6caOuYksiK+59RXFx883IyAAAAAAAAAACAhcyfP9/cxSZJHh4e8vPzk2EYOnnypIqKisxdcFFRUXrjjTfI6qBZAwMDdezYMRmGoYKCAklSeHj4HV/HMAytX7/e0vHqPAqEAAAAAAAAAADAZrZu3aro6GilpaVVec4wDHXv3l2RkZEKDg62Q7rKyHr3AgMDdfToURmGocLCQkmSp6fnHV/nh6+H5VAgBAAAAAAAAAAANpeXl6f09HSdP39ezs7O8vX1Vfv27dW4cWN7R6uCrHcuKipKZ86ckSQtXbpUkvTRRx/d1bWGDx9usVy4gQIhAAAAAAAAAAAAUIfUs3cAAAAAAAAAAAAA3F8+/vhji11r2LBhFrsWbqCDEAAAAAAAAAAAABbl6ekpwzDu6Romk4kzCK2EDkIAAAAAAAAAAABYVLdu3aotEF67dk179uwxP/b09FTz5s3l7OysrKwsczHQw8NDERERqlePUpY18F0FAAAAAAAAAACARSUkJFRZKysr06BBgyRJPXr00NSpU9W1a9dKew4ePKjo6GglJSXpwIEDWr16tU3y1jVO9g4AAAAAAAAAAACA+9+iRYu0Y8cODRkyRGvWrKlSHJSkTp06aeXKlRo2bJi2b9+uRYsW2SHp/Y8zCAEAAAAAAAAAAGB1QUFBOnz4sPbt26dWrVrVuPf48ePq3Lmz2rRpo7S0NBslrDvoIAQAAAAAAAAAAIDVnThxQpLk7+9/y71+fn6SpOzsbGtGqrMoEAIAAAAAAAAAAMDq3NzcJElHjhy55d6MjAxJUqNGjayaqa6iQAgAAAAAAAAAAACrCwgIkCTNmjVLJtPNT8AzmUyaNWuWDMNQYGCgreLVKRQIAQAAAAAAAAAAYHUTJkyQyWTSpk2bNGDAAO3du7fKnrS0NPXv31+bN2+WJE2cONHWMesEo7i4+OYlWgAAAAAAAAAAAMBC5s+fb+4OlCQPDw/5+fnJMAydPHlSRUVF5u7CqKgovfHGG3ZMe/+iQAgAAAAAAAAAAACb2bp1q6Kjo5WWllblOcMw1L17d0VGRio4ONgO6eoGCoQAAAAAAAAAAACwuby8PKWnp+v8+fNydnaWr6+v2rdvr8aNG9s72n2PAiEAAAAAAAAAAABQhzjZOwAAAAAAAAAAAAAA26FACAAAAAAAAAAAANQhFAgBAAAAAAAAAACAOoQCIQAAAAAAAAAAAFCHUCAEAAAAAAAAAAAA6hAKhAAAAAAAAAAAAEAdQoEQAAAAAAAAAAAAqEMoEAIAAAAAAAAAAAB1CAVCAAAAAAAAAAAAoA6hQAgAAAAAAAAAAADUIfXsHQAAAAAAgHt16NAhbdiwQT/72c80fPhwi1wzJSVFKSkp6tixo8LDwy1yTQAAAACoDeggBAAAAAA4vPT0dMXGxuqjjz6y2DVTUlIUGxurDRs2WOyaAAAAAFAbUCAEAAAAAAAAAAAA6hAKhAAAAAAAAAAAAEAdYhQXF5vsHQIAAAAAgB+7dOmSlixZojVr1igzM1PXrl1Ts2bN9Oyzz2rKlCl66KGHlJWVpQ4dOlR5rb+/v77++mvz45KSEv3xj3/Uxo0bdezYMV2+fFleXl7q0KGD/uu//ktDhgwx701JSVHfvn2rXDM4OFgJCQnW+WIBAAAAwIbq2TsAAAAAAAA/VlBQoLCwMP3f//1fpfUTJ05o+fLl2rBhg7Zt23Zb1yosLFSvXr2UkZFRaf3cuXP68ssv9eWXX+rgwYP6n//5H4vlBwAAAIDajBGjAAAAAIBaJy4uTv/3f/8nLy8vLV++XMePH9f333+vtWvX6qc//alyc3M1f/58/exnP1NxcbGWLl0q6UaXX3FxcaXuwUWLFikjI8N8re+++055eXnavXu3+vfvL0n64x//qPz8fElS9+7dVVxcrKlTp0qShg0bpuLiYroHAQAAANw3KBACAAAAAGqdL7/8UpI0ffp0vfDCC/L29pa7u7t69Oiht956S5K0Z8+e27rWpk2bJEkzZszQCy+8IB8fHzVo0EDt2rXTihUr1LBhQ5WXlyszM9MqXwsAAAAA1DaMGAUAAAAA1Dr169eXJF25cqXKc//93/+tfv36qV692/sn7YwZM3TlyhWFhIRU+z4eHh66dOmSrl27dm+hAQAAAMBBUCAEAAAAANQ63bt31/79+zV79mzl5+dr8ODB6tixo5ycnOTq6qoHH3zwtq/Vu3fvKmsmk0lZWVlauXKlzpw5Y8noAAAAAFDrUSAEAAAAANQ6U6dO1f79+5WSkqJFixZp0aJF8vLy0s9//nP17NnTPHb0duXm5mr16tXauXOnjh49qhMnTujy5ctW/AoAAAAAoPbiDEIAAAAAQK3j7u6ujRs3at26dXr55ZfVvHlzFRYWavPmzZoyZYo6dOigVatW3da1Pv30U3Xu3FmRkZFat26dLl++rB49eui3v/2tPv30U/30pz+18lcDAAAAALULHYQAAAAAgFrrmWee0TPPPCNJysrK0pdffqkVK1Zo//79mjBhgp566ik1b978pq/Pzs7Wq6++qrKyMk2YMEGvv/56lfGkzs7O1vwSAAAAAKDWoYMQAAAAAFCrnDt3Tu+9957ee+89lZaWmtd/9rOf6de//rW2bNmi5s2b68qVK/rnP/9Z47U2b96ssrIyPfnkk4qOjq5SHCwvL1dhYaE1vgwAAAAAqLXoIAQAAAAA1CpXr17V9OnTJUlt27bVc889V+l5FxcXOTnd+LxreXl5jdcqKiqSJLm6ulb7/IoVK1RcXHyvkQEAAADAodBBCAAAAACoVR566CG1bt1akjRp0iRt2bJFhYWFunLlitLT0zVixAhlZWXJ1dVVv/jFLyq99vvvv1dZWZn5cbt27SRJ//znP/WHP/xB586d08WLF3XgwAGNHz9eb731lnnvv/71r0qvNQxDknTy5EmZTCarfb0AAAAAYGtGcXEx/8oBAAAAANQqW7Zs0YsvvlipYPdDzs7OWrx4sf7rv/5LkrRr1y717t1bkuTu7q6HHnpI+/btU3l5ufr06aPdu3dXe51BgwbJ2dlZn376qSSpQ4cO2rlzpyQpPj5er776qiTJw8NDAQEBWrt2rUW/TgAAAACwBzoIAQAAAAC1znPPPacvv/xSL774ovz9/VW/fn3Vr19fLVq00PDhw7Vjxw5zcVCSnn76af32t7+Vr6+vSktL1aRJE0mSk5OT1qxZo9///vdq166dGjVqJC8vL/Xo0UN///vf9de//lWxsbHq3r27XF1d9bOf/cx8zRdeeEG//vWv5eXlVemaAAAAAODo6CAEAAAAAAAAAAAA6hA6CAEAAAAAAAAAAIA6hAIhAAAAAAAAAAAAUIdQIAQAAAAAAAAAAADqEAqEAAAAAAAAAAAAQB1CgRAAAAAAAAAAAACoQygQAgAAAAAAAAAAAHUIBUIAAAAAAAAAAACgDqFACAAAAAAAAAAAANQhFAgBAAAAAAAAAACAOoQCIQAAAAAAAAAAAFCHUCAEAAAAAAAAAAAA6hAKhAAAAAAAAAAAAEAdQoEQAAAAAAAAAAAAqEMoEAIAAAAAAAAAAAB1CAVCAAAAAAAAAAAAoA6hQAgAAAAAAAAAAADUIRQIAQAAAAAAAAAAgDqEAiEAAAAAAAAAAABQh1AgBAAAAAAAAAAAAOoQCoQAAAAAAAAAAABAHUKBEAAAAAAAAAAAAKhDKBACAAAAAAAAAAAAdQgFQgAAAAAAAAAAAKAOoUAIAAAAAAAAAAAA1CEUCAEAAAAAAAAAAIA6hAIhAAAAAAAAAAAAUIdQIAQAAAAAAAAAAADqEAqEAAAAAAAAAAAAQB1CgRAAAAAAAAAAAACoQygQAgAAAAAAAAAAAHUIBUIAAAAAAAAAAACgDqFACAAAAAAAAAAAANQhFAgBAAAAAAAAAACAOuT/A/9/w8YyAjyVAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 500, + "width": 900 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "columns = [x for x in stats_parse.index if 'dist_freq' in x and '-+' in x]\n", + "\n", + "plt.figure(figsize=[9, 5])\n", + "\n", + "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", + "\n", + "plt.xticks(rotation=90)\n", + "plt.yscale('log')\n", + "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ~~Single-cell example~~\n", + "\n", + "~~snHi-C dat on K562 from Ilya Flyamer:~~\n", + "\n", + "To be implemented" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 1000000 spots for SRR3344037\r\n", + "Written 1000000 spots for SRR3344037\r\n" + ] + } + ], + "source": [ + "# Download test data\n", + "! fastq-dump SRR3344037 --minSpotId 0 --maxSpotId 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pairtools/__init__.py b/pairtools/__init__.py index ceda0d19..9d019b53 100644 --- a/pairtools/__init__.py +++ b/pairtools/__init__.py @@ -123,6 +123,7 @@ def wrapper(*args, **kwargs): from .pairtools_restrict import restrict from .pairtools_phase import phase from .pairtools_parse import parse +from .pairtools_parse2 import parse2 from .pairtools_stats import stats from .pairtools_sample import sample from .pairtools_filterbycov import filterbycov diff --git a/pairtools/_headerops.py b/pairtools/_headerops.py index f6fc4b22..aef871f6 100644 --- a/pairtools/_headerops.py +++ b/pairtools/_headerops.py @@ -129,6 +129,23 @@ def get_chromsizes_from_pysam_header(samheader): return dict(chromsizes) +def get_chromsizes_from_pysam_header(samheader): + """Convert pysam header to pairtools chromosomes (ordered dict). + + Example of pysam header converted to dict: + dict([ + ('SQ', [{'SN': 'chr1', 'LN': 248956422}, + {'SN': 'chr10', 'LN': 133797422}, + {'SN': 'chr11', 'LN': 135086622}, + {'SN': 'chr12', 'LN': 133275309}]), + ('PG', [{'ID': 'bwa', 'PN': 'bwa', 'VN': '0.7.17-r1188', 'CL': 'bwa mem -t 8 -SP -v1 hg38.fa test_1.1.fastq.gz test_2.1.fastq.gz'}]) + ]) + """ + SQs = samheader.to_dict()["SQ"] + chromsizes = [(sq["SN"], int(sq["LN"])) for sq in SQs] + return dict(chromsizes) + + def get_chrom_order(chroms_file, sam_chroms=None): """ Produce an "enumeration" of chromosomes based on the list diff --git a/pairtools/_pairsam_format.py b/pairtools/_pairsam_format.py index 84963854..77ec1f3a 100644 --- a/pairtools/_pairsam_format.py +++ b/pairtools/_pairsam_format.py @@ -19,7 +19,7 @@ COLUMNS = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', 'strand1', 'strand2', 'pair_type', 'sam1', 'sam2', - 'junction_index'] + 'pair_index'] UNMAPPED_CHROM = '!' UNMAPPED_POS = 0 diff --git a/pairtools/_parse.py b/pairtools/_parse.py index ec291719..36f905ff 100644 --- a/pairtools/_parse.py +++ b/pairtools/_parse.py @@ -1,184 +1,214 @@ """ Set of functions used for pairsam parse, migrated from pairtools/pairtools_parse.py + +Parse operates with several basic data types: + +I. pysam-based: + 1. **sam entry** is a continuous aligned fragment of the read mapped to certain location in the genome. + Because we read sam entries from .sam/.bam files automatically with modified pysam, + each sam entry is in fact special AlignedSegmentPairtoolized Cython object + that has alignment attributes and can be easily accessed from Python. + + Sam entries are gathered into reads by `push_pysam` function. + + 2. **read** is a collection of sam entries corresponding to a single Hi-C molecule. + It is represented by three variables: + readID, sams1 and sams2, which keep left and right sam entries, correspondingly. + Read is populated from the stream of sam entries on a fly, the process happenning + in `streaming_classify` function. + +II. python-based data types are parsed from pysam-based ones: + + 1. **alignment** is a continuous aligned fragment represented as dictionary with relevant fields, + such as "chrom", "pos5", "pos3", "strand", "type", etc. + + `empty_alignment` creates empty alignment, + `parse_pysam_entry` create new alignments from pysam entries, + `mask_alignment` clears some fields of the alignment to match the default "unmapped" state. + + `flip_alignment`, `flip_orientation` and `flip_ends` are useful functions that help to orient alignments. + + 2. **pair** of two alignments is represented by three variables: + algn1 (left alignment), algn2 (right alignment) and pair_index. + Pairs are obtained by `parse_read` or `parse2_read`. + Additionally, these functions also output all alignments for each side. + """ from . import _pairsam_format - -def parse_sams_into_pair( - sams1, - sams2, - min_mapq, - max_molecule_size, - max_inter_align_gap, - walks_policy, - report_3_alignment_end, - sam_tags, - store_seq +def streaming_classify( + instream, + outstream, + chromosomes, + out_alignments_stream, + out_stat, + **kwargs ): """ - Parse sam entries corresponding to a Hi-C molecule into alignments - for a Hi-C pair. - Returns - ------- - algn1, algn2: dict - Two alignments selected for reporting as a Hi-C pair. - algns1, algns2 - All alignments, sorted according to their order in on a read. - junction_index - Junction index of a pair in the molecule. - """ + Parse input sam file into individual reads, pairs, walks, + then write to the outstream(s). + + Additional kwargs: + min_mapq, + drop_readid, + drop_seq, + drop_sam, + add_pair_index, + add_columns, # comma-separated list + report_alignment_end, + max_inter_align_gap + parse: + max_molecule_size + walks_policy + parse2: + single_end: indicator whether single-end data is provided + report_position, one of: "outer", "junction", "read", "walk" + report_orientation, one of: "pair", "junction", "read", "walk" + allowed_offset: For detection of overlaps of pairs and ends + max_fragment_size: maximum fragment size to search for overlapping ends - # Check if there is at least one SAM entry per side: - if (len(sams1) == 0) or (len(sams2) == 0): - algns1 = [empty_alignment()] - algns2 = [empty_alignment()] - algns1[0]["type"] = "X" - algns2[0]["type"] = "X" - junction_index = "1u" # By default, assume each molecule is a single ligation with single unconfirmed junction - return [[algns1[0], algns2[0], algns1, algns2, junction_index]] - - # Generate a sorted, gap-filled list of all alignments - algns1 = [ parse_algn_pysam(sam, min_mapq, report_3_alignment_end, sam_tags, store_seq) for sam in sams1 ] - algns2 = [ parse_algn_pysam(sam, min_mapq, report_3_alignment_end, sam_tags, store_seq) for sam in sams2 ] - algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) - algns2 = sorted(algns2, key=lambda algn: algn["dist_to_5"]) + """ - if max_inter_align_gap is not None: - _convert_gaps_into_alignments(algns1, max_inter_align_gap) - _convert_gaps_into_alignments(algns2, max_inter_align_gap) + parse2 = kwargs.get("parse2", False) - # Define the type of alignment on each side. - # The most important split is between chimeric alignments and linear - # alignments. + ### Store output parameters in a usable form: + chrom_enum = dict( + zip( + [_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), + range(len(chromosomes) + 1), + ) + ) + add_columns = kwargs.get("add_columns", "").split(',') + sam_tags = [col for col in add_columns if len(col) == 2 and col.isupper()] + store_seq = "seq" in add_columns + + ### Compile readID transformation: + readID_transform = kwargs.get("readid_transform", None) + if readID_transform is not None: + readID_transform = compile(readID_transform, "", "eval") + + ### Prepare for iterative parsing of the input stream + # Each read is represented by readID, sams1 (left alignments) and sams2 (right alignments) + readID = "" # Read id of the current read + sams1 = [] # Placeholder for the left alignments + sams2 = [] # Placeholder for the right alignments + # Each read is comprised of multiple alignments, or sam entries: + sam_entry = "" # Placeholder for each aligned segment + # Keep the id of the previous sam entry to detect when the read is completely populated: + prev_readID = "" # Placeholder for the read id + + ### Iterate over input pysam: + instream = iter(instream) + while sam_entry is not None: + sam_entry = next(instream, None) + + readID = sam_entry.query_name if sam_entry else None + if readID_transform is not None and readID is not None: + readID = eval(readID_transform) + + # Read is fully populated, then parse and write: + if not (sam_entry) or ((readID != prev_readID) and prev_readID): + + ### Parse + if not parse2: # regular parser: + pairstream, all_algns1, all_algns2 = parse_read( + sams1, + sams2, + min_mapq=kwargs["min_mapq"], + max_molecule_size=kwargs["max_molecule_size"], + max_inter_align_gap=kwargs["max_inter_align_gap"], + walks_policy=kwargs["walks_policy"], + sam_tags=sam_tags, + store_seq=store_seq + ) + else: # parse2 parser: + pairstream, all_algns1, all_algns2 = parse2_read( + sams1, + sams2, + min_mapq=kwargs["min_mapq"], + max_inter_align_gap=kwargs["max_inter_align_gap"], + max_fragment_size=kwargs["max_fragment_size"], + single_end=kwargs["single_end"], + report_position=kwargs["report_position"], + report_orientation=kwargs["report_orientation"], + sam_tags=sam_tags, + allowed_offset=kwargs["allowed_offset"], + store_seq=store_seq + ) - is_chimeric_1 = len(algns1) > 1 - is_chimeric_2 = len(algns2) > 1 + ### Write: + read_has_alignments = False + for (algn1, algn2, pair_index) in pairstream: + read_has_alignments = True - hic_algn1 = algns1[0] - hic_algn2 = algns2[0] - junction_index = "1u" # By default, assume each molecule is a single ligation with single unconfirmed junction + if kwargs["report_alignment_end"] == "5": + algn1["pos"] = algn1["pos5"] + algn2["pos"] = algn2["pos5"] + else: + algn1["pos"] = algn1["pos3"] + algn2["pos"] = algn2["pos3"] + + if not kwargs["no_flip"]: + flip_pair = not check_pair_order(algn1, algn2, chrom_enum) + if flip_pair: + algn1, algn2 = algn2, algn1 + sams1, sams2 = sams2, sams1 + + write_pairsam( + algn1, + algn2, + readID=prev_readID, + pair_index=pair_index, + sams1=sams1, + sams2=sams2, + out_file=outstream, + drop_readid=kwargs["drop_readid"], + drop_seq=kwargs["drop_seq"], + drop_sam=kwargs["drop_sam"], + add_pair_index=kwargs["add_pair_index"], + add_columns=kwargs["add_columns"] + ) - # Parse chimeras - rescued_linear_side = None - if is_chimeric_1 or is_chimeric_2: + # add a pair to PairCounter for stats output: + if out_stat: + out_stat.add_pair( + algn1["chrom"], + int(algn1["pos"]), + algn1["strand"], + algn2["chrom"], + int(algn2["pos"]), + algn2["strand"], + algn1["type"] + algn2["type"], + ) - # Report all the linear alignments in a read pair - if walks_policy == "all": - # Report linear alignments after deduplication of complex walks - return rescue_complex_walk(algns1, algns2, max_molecule_size) + # write all alignments: + if out_alignments_stream and read_has_alignments: + write_all_algnments( + prev_readID, all_algns1, all_algns2, out_alignments_stream + ) - # Report only two alignments for a read pair - rescued_linear_side = rescue_walk(algns1, algns2, max_molecule_size) + # Empty read after writing: + sams1.clear() + sams2.clear() - # Walk was rescued as a simple walk: - if rescued_linear_side is not None: - junction_index = ( - f'{1}{"f" if rescued_linear_side==1 else "r"}' # TODO: replace - ) - # Walk is unrescuable: - else: - if walks_policy == "mask": - hic_algn1 = _mask_alignment(dict(hic_algn1)) - hic_algn2 = _mask_alignment(dict(hic_algn2)) - hic_algn1["type"] = "W" - hic_algn2["type"] = "W" - - elif walks_policy == "5any": - hic_algn1 = algns1[0] - hic_algn2 = algns2[0] - - elif walks_policy == "5unique": - hic_algn1 = algns1[0] - for algn in algns1: - if algn["is_mapped"] and algn["is_unique"]: - hic_algn1 = algn - break - - hic_algn2 = algns2[0] - for algn in algns2: - if algn["is_mapped"] and algn["is_unique"]: - hic_algn2 = algn - break - - elif walks_policy == "3any": - hic_algn1 = algns1[-1] - hic_algn2 = algns2[-1] - - elif walks_policy == "3unique": - hic_algn1 = algns1[-1] - for algn in algns1[::-1]: - if algn["is_mapped"] and algn["is_unique"]: - hic_algn1 = algn - break - - hic_algn2 = algns2[-1] - for algn in algns2[::-1]: - if algn["is_mapped"] and algn["is_unique"]: - hic_algn2 = algn - break - - # lower-case reported walks on the chimeric side - if walks_policy != "mask": - if is_chimeric_1: - hic_algn1 = dict(hic_algn1) - hic_algn1["type"] = hic_algn1["type"].lower() - if is_chimeric_2: - hic_algn2 = dict(hic_algn2) - hic_algn2["type"] = hic_algn2["type"].lower() - - return [[hic_algn1, hic_algn2, algns1, algns2, junction_index]] - - -def parse_cigar_pysam(read): - """Parse cigar tuples reported as cigartuples of pysam read entry. - Reports alignment span, clipped nucleotides and more. - See https://pysam.readthedocs.io/en/latest/api.html#pysam.AlignedSegment.cigartuples - - :param read: input pysam read entry - :return: parsed aligned entry (dictionary) + if sam_entry is not None: + push_pysam(sam_entry, sams1, sams2) + prev_readID = readID - """ - matched_bp = 0 - algn_ref_span = 0 - algn_read_span = 0 - read_len = 0 - clip5_ref = 0 - clip3_ref = 0 - - cigarstring = read.cigarstring - cigartuples = read.cigartuples - if cigartuples is not None: - for operation, length in cigartuples: - if operation == 0: # M, match - matched_bp += length - algn_ref_span += length - algn_read_span += length - read_len += length - elif operation == 1: # I, insertion - algn_read_span += length - read_len += length - elif operation == 2: # D, deletion - algn_ref_span += length - elif ( - operation == 4 or operation == 5 - ): # S and H, soft clip and hard clip, respectively - read_len += length - if matched_bp == 0: - clip5_ref = length - else: - clip3_ref = length - return { - "clip5_ref": clip5_ref, - "clip3_ref": clip3_ref, - "cigar": cigarstring, - "algn_ref_span": algn_ref_span, - "algn_read_span": algn_read_span, - "read_len": read_len, - "matched_bp": matched_bp, - } +############################ +### Alignment utilities: ### +############################ +def push_pysam(sam_entry, sams1, sams2): + """Parse pysam AlignedSegment (sam) into pairtools sams entry""" + flag = sam_entry.flag + if (flag & 0x40) != 0: + sams1.append(sam_entry) # left read, or first read in a pair + else: + sams2.append(sam_entry) # right read, or mate pair + return def empty_alignment(): return { @@ -203,16 +233,15 @@ def empty_alignment(): "type": "N", } - -def parse_algn_pysam( - sam, min_mapq, report_3_alignment_end=False, sam_tags=None, store_seq=False +def parse_pysam_entry( + sam, min_mapq, sam_tags=None, store_seq=False, report_3_alignment_end=False ): """Parse alignments from pysam AlignedSegment entry :param sam: input pysam AlignedSegment entry :param min_mapq: minimal MAPQ to consider as a proper alignment - :param report_3_alignment_end: if True, 3'-end of alignment will be reported as position :param sam_tags: list of sam tags to store :param store_seq: if True, the sequence will be parsed and stored in the output + :param report_3_alignment_end: if True, 3'-end of alignment will be reported as position (will be deprecated) :return: parsed aligned entry (dictionary) """ @@ -221,9 +250,7 @@ def parse_algn_pysam( mapq = sam.mapq is_unique = sam.is_unique(min_mapq) is_linear = sam.is_linear - - cigar = parse_cigar_pysam(sam) - + cigar = sam.cigar_dict if is_mapped: if (flag & 0x10) == 0: strand = "+" @@ -237,15 +264,14 @@ def parse_algn_pysam( if is_unique: chrom = sam.reference_name if strand == "+": - pos5 = ( - sam.reference_start + 1 - ) # Note that pysam output is zero-based, thus add +1 - pos3 = sam.reference_end + cigar["algn_ref_span"] # - 1 + # Note that pysam output is zero-based, thus add +1: + pos5 = sam.reference_start + 1 + pos3 = sam.reference_start + cigar["algn_ref_span"] else: - pos5 = sam.reference_start + cigar["algn_ref_span"] # - 1 - pos3 = ( - sam.reference_end + 1 - ) # Note that pysam output is zero-based, thus add +1 + pos5 = sam.reference_start + cigar["algn_ref_span"] + # Note that pysam output is zero-based, thus add +1: + pos3 = sam.reference_start + 1 + else: chrom = _pairsam_format.UNMAPPED_CHROM strand = _pairsam_format.UNMAPPED_STRAND @@ -295,6 +321,279 @@ def parse_algn_pysam( return algn +def mask_alignment(algn): + """ + Reset the coordinates of an alignment. + """ + algn["chrom"] = _pairsam_format.UNMAPPED_CHROM + algn["pos5"] = _pairsam_format.UNMAPPED_POS + algn["pos3"] = _pairsam_format.UNMAPPED_POS + algn["pos"] = _pairsam_format.UNMAPPED_POS + algn["strand"] = _pairsam_format.UNMAPPED_STRAND + + return algn + +def flip_alignment(hic_algn): + """ + Flip a single alignment as if it was sequenced from the opposite end + :param hic_algn: Alignment to be modified + :return: + """ + hic_algn = dict(hic_algn) # overwrite the variable with the copy of dictionary + hic_algn["pos5"], hic_algn["pos3"] = hic_algn["pos3"], hic_algn["pos5"] + hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" + return hic_algn + +def flip_orientation(hic_algn): + """ + Flip orientation of a single alignment + :param hic_algn: Alignment to be modified + :return: + """ + hic_algn = dict(hic_algn) # overwrite the variable with the copy of dictionary + hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" + return hic_algn + +def flip_position(hic_algn): + """ + Flip ends of a single alignment + :param hic_algn: Alignment to be modified + :return: + """ + hic_algn = dict(hic_algn) # overwrite the variable with the copy of dictionary + hic_algn["pos5"], hic_algn["pos3"] = hic_algn["pos3"], hic_algn["pos5"] + return hic_algn + + +#################### +### Parsing utilities: +#################### + +def parse_read( + sams1, + sams2, + min_mapq, + max_molecule_size, + max_inter_align_gap, + walks_policy, + sam_tags, + store_seq +): + """ + Parse sam entries corresponding to a single read (or Hi-C molecule) + into pairs of alignments. + + Returns + ------- + stream: iterator + Each element is a triplet: (algn1, aldn2, pair_index) + algn1, algn2: dict + Two alignments selected for reporting as a Hi-C pair. + pair_index + pair index of a pair in the molecule. + algns1, algns2: lists + All alignments, sorted according to their order in on a read. + """ + + # Check if there is at least one sam entry per side: + if (len(sams1) == 0) or (len(sams2) == 0): + algns1 = [empty_alignment()] + algns2 = [empty_alignment()] + algns1[0]["type"] = "X" + algns2[0]["type"] = "X" + pair_index = "1u" + return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 + + # Generate a sorted, gap-filled list of all alignments + algns1 = [ parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1 ] + algns2 = [ parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2 ] + + algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) + algns2 = sorted(algns2, key=lambda algn: algn["dist_to_5"]) + + if max_inter_align_gap is not None: + _convert_gaps_into_alignments(algns1, max_inter_align_gap) + _convert_gaps_into_alignments(algns2, max_inter_align_gap) + + # By default, assume each molecule is a single pair with single unconfirmed pair: + hic_algn1 = algns1[0] + hic_algn2 = algns2[0] + pair_index = "1u" + + # Define the type of alignment on each side: + is_chimeric_1 = len(algns1) > 1 + is_chimeric_2 = len(algns2) > 1 + + # Parse chimeras + if is_chimeric_1 or is_chimeric_2: + + # Report all the linear alignments in a read pair + if walks_policy == "all": + # Report linear alignments after deduplication of complex walks with default settings: + return parse_complex_walk(algns1, algns2, max_molecule_size, + report_position="outer", + report_orientation="pair"), algns1, algns2 + + elif walks_policy in ['mask', '5any', '5unique', '3any', '3unique']: + # Report only two alignments for a read pair + rescued_linear_side = rescue_walk(algns1, algns2, max_molecule_size) + + # Walk was rescued as a simple walk: + if rescued_linear_side is not None: + pair_index = f'1{"l" if rescued_linear_side==1 else "r"}' + # Walk is unrescuable: + else: + if walks_policy == "mask": + hic_algn1 = mask_alignment(dict(hic_algn1)) + hic_algn2 = mask_alignment(dict(hic_algn2)) + hic_algn1["type"] = "W" + hic_algn2["type"] = "W" + + elif walks_policy == "5any": + hic_algn1 = algns1[0] + hic_algn2 = algns2[0] + + elif walks_policy == "5unique": + hic_algn1 = algns1[0] + for algn in algns1: + if algn["is_mapped"] and algn["is_unique"]: + hic_algn1 = algn + break + + hic_algn2 = algns2[0] + for algn in algns2: + if algn["is_mapped"] and algn["is_unique"]: + hic_algn2 = algn + break + + elif walks_policy == "3any": + hic_algn1 = algns1[-1] + hic_algn2 = algns2[-1] + + elif walks_policy == "3unique": + hic_algn1 = algns1[-1] + for algn in algns1[::-1]: + if algn["is_mapped"] and algn["is_unique"]: + hic_algn1 = algn + break + + hic_algn2 = algns2[-1] + for algn in algns2[::-1]: + if algn["is_mapped"] and algn["is_unique"]: + hic_algn2 = algn + break + + # lower-case reported walks on the chimeric side + if walks_policy != "mask": + if is_chimeric_1: + hic_algn1 = dict(hic_algn1) + hic_algn1["type"] = hic_algn1["type"].lower() + if is_chimeric_2: + hic_algn2 = dict(hic_algn2) + hic_algn2["type"] = hic_algn2["type"].lower() + + else: + raise ValueError(f"Walks policy {walks_policy} is not supported.") + + return iter([(hic_algn1, hic_algn2, pair_index)]), algns1, algns2 + + +def parse2_read( + sams1, + sams2, + min_mapq, + max_inter_align_gap, + max_fragment_size, + single_end, + report_position="outer", + report_orientation="pair", + sam_tags=[], + allowed_offset=3, + store_seq=False +): + """ + Parse sam entries corresponding to a Hi-C molecule into alignments in parse2 mode + for a Hi-C pair. + Returns + ------- + stream: iterator + Each element is a triplet: (algn1, aldn2, pair_index) + algn1, algn2: dict + Two alignments selected for reporting as a Hi-C pair. + pair_index + pair index of a pair in the molecule. + algns1, algns2: lists + All alignments, sorted according to their order in on a read. + """ + + # Single-end mode: + if single_end: + # Generate a sorted, gap-filled list of all alignments + algns1 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1] + algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) + if max_inter_align_gap is not None: + _convert_gaps_into_alignments(algns1, max_inter_align_gap) + + algns2 = [empty_alignment()] # Empty alignment dummy + + if len(algns1) > 1: + # Look for ligation pair, and report linear alignments after deduplication of complex walks: + # (Note that coordinate system for single-end reads does not change the behavior) + return parse_complex_walk( + algns1, algns2, max_fragment_size, report_position, report_orientation, allowed_offset + ), algns1, algns2 + else: + # If no additional information, we assume each molecule is a single ligation with single unconfirmed pair: + algn2 = algns2[0] + if report_orientation == "walk": + algn2 = flip_orientation(algn2) + if report_position == "walk": + algn2 = flip_position(algn2) + return iter([(algns1[0], algn2, "1u")]), algns1, algns2 + + # Paired-end mode: + else: + # Check if there is at least one SAM entry per side: + if (len(sams1) == 0) or (len(sams2) == 0): + algns1 = [empty_alignment()] + algns2 = [empty_alignment()] + algns1[0]["type"] = "X" + algns2[0]["type"] = "X" + return iter([(algns1[0], algns2[0], "1u")]), algns1, algns2 + + # Generate a sorted, gap-filled list of all alignments + algns1 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1] + algns2 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2] + + algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) + algns2 = sorted(algns2, key=lambda algn: algn["dist_to_5"]) + + if max_inter_align_gap is not None: + _convert_gaps_into_alignments(algns1, max_inter_align_gap) + _convert_gaps_into_alignments(algns2, max_inter_align_gap) + + is_chimeric_1 = len(algns1) > 1 + is_chimeric_2 = len(algns2) > 1 + + if is_chimeric_1 or is_chimeric_2: + # If at least one side is chimera, we must look for ligation pair, and + # report linear alignments after deduplication of complex walks: + return parse_complex_walk( + algns1, algns2, max_fragment_size, report_position, report_orientation + ), algns1, algns2 + else: + # If no additional information, we assume each molecule is a single ligation with single unconfirmed pair: + algn2 = algns2[0] + if report_orientation == "walk": + algn2 = flip_orientation(algn2) + if report_position == "walk": + algn2 = flip_position(algn2) + return iter([(algns1[0], algn2, "1u")]), algns1, algns2 + + +#################### +### Walks utilities: +#################### def rescue_walk(algns1, algns2, max_molecule_size): """ @@ -303,10 +602,10 @@ def rescue_walk(algns1, algns2, max_molecule_size): ligation between two fragments, where one fragment was so long that it got sequenced on both sides. Uses three criteria: - a) the 3'-end alignment on one side maps to the same chromosome as the + 1) the 3'-end alignment on one side maps to the same chromosome as the alignment fully covering the other side (i.e. the linear alignment) - b) the two alignments point towards each other on the chromosome - c) the distance between the outer ends of the two alignments is below + 2) the two alignments point towards each other on the chromosome + 3) the distance between the outer ends of the two alignments is below the specified threshold. Alternatively, a single ligation get rescued when the 3' sub-alignment maps to multiple locations or no locations at all. @@ -381,291 +680,263 @@ def rescue_walk(algns1, algns2, max_molecule_size): can_rescue &= molecule_size <= max_molecule_size if can_rescue: + # changing the type of the 3' alignment on side 1, does not show up in the output: if first_read_is_chimeric: - # changing the type of the 3' alignment on side 1, does not show up - # in the output + algns1[1]["type"] = "X" algns2[0]["type"] = "R" return 1 + # changing the type of the 3' alignment on side 2, does not show up in the output: else: algns1[0]["type"] = "R" - # changing the type of the 3' alignment on side 2, does not show up - # in the output algns2[1]["type"] = "X" return 2 else: return None - -def rescue_complex_walk(algns1, algns2, max_molecule_size, allowed_offset=3): +def _convert_gaps_into_alignments(sorted_algns, max_inter_align_gap): """ - Rescue a set of ligations that appear as a complex walk. - - This rescue differs from simple rescue_walk by the step of deduplication. - If the reads are long enough, the reverse read might read through the forward read's meaningful part. - If one of the reads contains ligation junction, this might lead to reporting fake contact. - Thus, the pairs of contacts that overlap are paired-end duplicates and should be reported uniquely. - - Return: list of all the rescued pairs after deduplication with junction index for each pair. + Inplace conversion of gaps longer than max_inter_align_gap into alignments + """ + if (len(sorted_algns) == 1) and (not sorted_algns[0]["is_mapped"]): + return - Example of iterative search (note that it's for the illustration of the algorithm only): + last_5_pos = 0 + for i in range(len(sorted_algns)): + algn = sorted_algns[i] + if algn["dist_to_5"] - last_5_pos > max_inter_align_gap: + new_algn = empty_alignment() + new_algn["dist_to_5"] = last_5_pos + new_algn["algn_read_span"] = algn["dist_to_5"] - last_5_pos + new_algn["read_len"] = algn["read_len"] + new_algn["dist_to_3"] = new_algn["read_len"] - algn["dist_to_5"] - Forward read: Reverse read: - ----------------------> <----------------------- - algns1 algns2 - 5---3_5---3_5---3_5---3 3---5_3---5_3---5_3---5 - fIII fII fI rI rII rIII - junctions junctions + last_5_pos = algn["dist_to_5"] + algn["algn_read_span"] - Alignment is a bwa mem reported hit. After parsing of bam file, all the alignments are reported in - sequential order as algns1 for forward and algns2 for reverse reads. - Junction is a sequential pair of linear alignments reported as chimera at forward or reverse read. + sorted_algns.insert(i, new_algn) + i += 2 + else: + last_5_pos = max(last_5_pos, algn["dist_to_5"] + algn["algn_read_span"]) + i += 1 - Let's consider the case if n_algns1 >= 2 on forward read and n_algns2 >= 2 on reverse read. - We start looking for overlapping pairs of linear alignments from the ends of reads. +def parse_complex_walk( + algns1, + algns2, + max_fragment_size, + report_position, + report_orientation, + allowed_offset=3 +): + """ + Parse a set of ligations that appear as a complex walk. + This procedure is equivalent to intramolecular deduplication that preserved pair order in a walk. + + :param algns1: List of sequential lefts alignments + :param algns2: List of sequential right alignments + :param max_fragment_size: maximum expected restriction/digestion fragment size + :param report_position: one of "outer", "junction", "read", "walk"; sets pos5 and pos3 + :param report_orientation: one of "pair", "junction", "read", "walk"; sets strand + :param allowed_offset: the number of basepairs that are allowed at the ends of alignments to detect overlaps + + :return: iterator with parsed pairs + + **Intramolecular deduplication** + + Forward read (left): right read (right): + 5'------------------------->3' 3'<--------------------------5' + algns1 algns2 + <5---3><5---3><5---3><5---3> <3---5><3---5><3---5><3---5> + l0 l1 l2 l3 r3 r2 r1 r0 + + Alignment - bwa mem reported hit or alignment after gaps conversion. + Left and right alignments (algns1: [l0, l1, l2, l3], algns2: [r0, r1, r2, r3]) + - alignments on left and right reads reported from 5' to 3' orientation. + + Intramolecular deduplication consists of two steps: + I. iterative search of overlapping alignment pairs (aka overlap), + II. if no overlaps or search not possible (less than 2 alignments on either sides), + search for overlap of end alignments (aka partial overlap). + III. report pairs before the overlap, deduplicated pairs of overlap and pairs after that. + + Iterative search of overlap is in fact scanning of the right read pairs for the hit + with the 3'-most pair of the left read: + 1. Initialize. + Start from 3' of left and right reads. Set `current_left_pair` and `current_right_pair` pointers + 2. Initial compare. + Compare pairs l2-l3 and r3-r2 by `pairs_overlap`. + If successful, we found the overlap, go to reporting. + If unsuccessful, continue search. + 3. Increment. + Shift `current_right_pair` pointer by one (e.g., take the pair r2-r1). + 4. Check. + Check that this pair can form a potential overlap with left alignments: + the number of pairs downstream from l2-l3 on left read should not be less than + the number of pairs upstream from r2-r1 on right read. + If overlap cannot be formed, no other overlap in this complex walk is possible, safely exit. + If the potential overlap can be formed, continue comparison. + 5. Compare. + Compare the current pair of pairs on left and right reads. + If comparison fails, go to step 3. + If comparison is successful, go to 6. + 6. Verify. + Check that downstream pairs on the left read overlap with the upstream pairs on the right read. + If yes, exit. + If not, we do not have an overlap, go to step 3. + """ - The procedure of iterative search of overlap: - 1. Take the last 3' junction on the forward read (fI, or current_forward_junction) - and the last 3' junction on reverse read (rI, or current_reverse_junction). - 2. Compare fI and rI (pairs_do_overlap). - If successful, we found the overlap, add it to the output list. - If not successful, go to p.3. - 3. Take the next pair of linear alignments of reverse read (rII), i.e. shift current_reverse_junction by one. - 4. Check that this pair can form a potential overlap with fI: - the number of junctions downstream from fI on forward read should not be less than - the number of junctions upstream from rII on reverse read. - If the potential overlap can be formed, go to p. 5. - If it cannot be formed, no other overlap in this complex walk is possible. Exit. - 5. Compare the current pair of junctions on forward and reverse reads. - If comparison fails, go to p. 3, i.e. take the next pair of linear alignments of reverse read (rIII). - If comparison is successful, check that junctions downstream from fI overlap with the junctions upstream from rII. - If yes, add them all to the output list. - If not, we do not have an overlap, repeat p. 3. + AVAILABLE_REPORT_POSITION = ["outer", "junction", "read", "walk"] + assert report_position in AVAILABLE_REPORT_POSITION, ( + f"Cannot report position {report_position}, as it is not implemented" + f'Available choices are: {", ".join(AVAILABLE_REPORT_POSITION)}' + ) - Note that we do not need to perform the shifts on the forward read, because - biologically overlap can only happen involving both ends of forward and reverse read, - and shifting one of them is enough. - """ + AVAILABLE_REPORT_ORIENTATION = ["pair", "junction", "read", "walk"] + assert report_orientation in AVAILABLE_REPORT_ORIENTATION, ( + f"Cannot report orientation {report_orientation}, as it is not implemented" + f'Available choices are: {", ".join(AVAILABLE_REPORT_ORIENTATION)}' + ) + output_pairs = [] + + # Initialize (step 1). n_algns1 = len(algns1) n_algns2 = len(algns2) - - # Iterative search of overlap - current_forward_junction = current_reverse_junction = 1 # p. 1, initialization - remaining_forward_junctions = ( - n_algns1 - 1 - ) # Number of possible junctions remaining on forward read - remaining_reverse_junctions = ( - n_algns2 - 1 - ) # Number of possible junctions remaining on reverse read - checked_reverse_junctions = ( - 0 # Number of checked junctions on reverse read (from the end of read) - ) + current_left_pair = current_right_pair = 1 + remaining_left_pairs = n_algns1 - 1 # Number of possible pairs remaining on left read + remaining_right_pairs = n_algns2 - 1 # Number of possible pairs remaining on right read + checked_right_pairs = 0 # Number of checked pairs on right read (from the end of read) is_overlap = False - final_contacts = [] - - # If both sides have more than 2 alignments, rescue complex walks + # I. Iterative search of overlap, at least two alignments on each side: if (n_algns1 >= 2) and (n_algns2 >= 2): - - # p. 4: if potential overlap can be formed - while (remaining_forward_junctions > checked_reverse_junctions) and ( - remaining_reverse_junctions > 0 - ): - - # p. 5: check the current pairs of junctions - is_overlap = pairs_do_overlap( - ( - algns1[-current_forward_junction - 1], - algns1[-current_forward_junction], - ), - ( - algns2[-current_reverse_junction - 1], - algns2[-current_reverse_junction], - ), - allowed_offset, - ) - - # p. 5: check the remaining pairs of forward downstream / reverse upstream junctions + # Iteration includes check (step 4): + while (remaining_left_pairs > checked_right_pairs) and (remaining_right_pairs > 0): + pair1 = (algns1[-current_left_pair - 1], algns1[-current_left_pair] ) + pair2 = (algns2[-current_right_pair - 1], algns2[-current_right_pair]) + # Compare (initial or not, step 2 or 5): + is_overlap = pairs_overlap(pair1, pair2, allowed_offset=allowed_offset) if is_overlap: - last_idx_forward_temp = current_forward_junction - last_idx_reverse_temp = current_reverse_junction - checked_reverse_temp = checked_reverse_junctions - while is_overlap and (checked_reverse_temp > 0): - last_idx_forward_temp += 1 - last_idx_reverse_temp -= 1 - is_overlap &= pairs_do_overlap( - ( - algns1[-last_idx_forward_temp - 1], - algns1[-last_idx_forward_temp], - ), - ( - algns2[-last_idx_reverse_temp - 1], - algns2[-last_idx_reverse_temp], - ), - allowed_offset, - ) - checked_reverse_temp -= 1 - if is_overlap: - current_reverse_junction += 1 + last_idx_left_temp = current_left_pair + last_idx_right_temp = current_right_pair + checked_right_temp = checked_right_pairs + # Verify (step 6): + while is_overlap and (checked_right_temp > 0): + last_idx_left_temp += 1 + last_idx_right_temp -= 1 + pair1 = (algns1[-last_idx_left_temp - 1], algns1[-last_idx_left_temp]) + pair2 = (algns2[-last_idx_right_temp - 1], algns2[-last_idx_right_temp]) + is_overlap &= pairs_overlap(pair1, pair2, allowed_offset=allowed_offset) + checked_right_temp -= 1 + if is_overlap: # exit + current_right_pair += 1 break - # p. 3: shift the reverse junction pointer by one - current_reverse_junction += 1 - checked_reverse_junctions += 1 - remaining_reverse_junctions -= 1 - - if ( - not is_overlap - ): # No overlap found, roll the current_idx_reverse back to the initial value - current_reverse_junction = 1 - - # If no overlapping junctions found, or there are less than 2 chimeras in either forward or reverse read, - # then current_reverse_junction is 1, - # check whether the last alignments of forward and reverse reads overlap. - if current_reverse_junction == 1: - last_reported_alignment_forward = last_reported_alignment_reverse = 1 - if ends_do_overlap(algns1[-1], algns2[-1], max_molecule_size, allowed_offset): - # Report the modified last junctions: - if n_algns1 >= 2: - # store the type of contact and do not modify original entry: - hic_algn1 = dict(algns1[-2]) - hic_algn2 = dict(algns2[-1]) - # Modify pos3 of reverse read alignment to correspond to actual observed 5' ends in forward read: - hic_algn2["pos3"] = algns1[-1]["pos5"] - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{len(algns1)-1}f" - final_contacts.append( - [hic_algn1, hic_algn2, algns1, algns2, junction_index] - ) - last_reported_alignment_forward = 2 - if n_algns2 >= 2: - # store the type of contact and do not modify original entry: - hic_algn1 = dict(algns1[-1]) - hic_algn2 = dict(algns2[-2]) - # Modify pos3 of forward read alignment to correspond to actual observed 5' ends in reverse read: - hic_algn1["pos3"] = algns2[-1]["pos5"] - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{len(algns1)}r" - final_contacts.append( - [hic_algn1, hic_algn2, algns1, algns2, junction_index] - ) - last_reported_alignment_reverse = 2 - # End alignments do not overlap. No evidence of ligation junction for the pair, report regular pair: - else: - hic_algn1 = dict( - algns1[-1] - ) # "dict" trick to store the type of contact and not modify original entry - hic_algn2 = dict(algns2[-1]) - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{len(algns1)}u" - final_contacts.append( - [hic_algn1, hic_algn2, algns1, algns2, junction_index] - ) - - # If we have an overlap of junctions: - else: - last_reported_alignment_forward = ( - last_reported_alignment_reverse - ) = current_reverse_junction - - # Report all the sequential alignments - # Report all the sequential chimeric pairs in the forward read up to overlap: - for i in range(0, n_algns1 - last_reported_alignment_forward): - hic_algn1 = dict(algns1[i]) - hic_algn2 = dict(algns1[i + 1]) - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{i + 1}f" - final_contacts.append([hic_algn1, hic_algn2, algns1, algns2, junction_index]) - - # Report the overlap - for i_overlapping in range(current_reverse_junction - 1): - idx_forward = n_algns1 - current_reverse_junction + i_overlapping - idx_reverse = n_algns2 - 1 - i_overlapping - - hic_algn1 = dict(algns1[idx_forward]) - hic_algn2 = dict(algns1[idx_forward + 1]) - hic_algn2["pos3"] = algns2[idx_reverse - 1]["pos5"] - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{idx_forward + 1}b" - final_contacts.append([hic_algn1, hic_algn2, algns1, algns2, junction_index]) - - # Report all the sequential chimeric pairs in the reverse read, but not the overlap: - for i in range( - 0, min(current_reverse_junction, n_algns2 - last_reported_alignment_reverse) - ): - hic_algn1 = dict(algns2[i]) - hic_algn2 = dict(algns2[i + 1]) - hic_algn1["type"] = ( - "N" - if not hic_algn1["is_mapped"] - else ("M" if not hic_algn1["is_unique"] else "U") - ) - hic_algn2["type"] = ( - "N" - if not hic_algn2["is_mapped"] - else ("M" if not hic_algn2["is_unique"] else "U") - ) - junction_index = f"{n_algns1 + min(current_reverse_junction, n_algns2 - last_reported_alignment_reverse) - i - (1 if current_reverse_junction>1 else 0)}r" - final_contacts.append([hic_algn1, hic_algn2, algns1, algns2, junction_index]) - - final_contacts.sort(key=lambda x: int(x[-1][:-1])) - return final_contacts + # Increment pointers (step 3) + current_right_pair += 1 + checked_right_pairs += 1 + remaining_right_pairs -= 1 + + # No overlap found, roll the current_idx_right back to the initial value: + if not is_overlap: + current_right_pair = 1 + + # II. Search of partial overlap if there are less than 2 alignments at either sides, or no overlaps found + if current_right_pair == 1: + last_reported_alignment_left = last_reported_alignment_right = 1 + if partial_overlap(algns1[-1], algns2[-1], max_fragment_size=max_fragment_size, allowed_offset=allowed_offset): + if (n_algns1 >= 2): # single alignment on right read and multiple alignments on left + output_pairs.append(format_pair( + algns1[-2], + algns1[-1], + pair_index=f"{len(algns1)-1}l", + algn2_pos3=algns2[-1]["pos5"], + report_position=report_position, + report_orientation=report_orientation + )) + last_reported_alignment_left = 2 # set the pointer for reporting + + if (n_algns2 >= 2): # single alignment on left read and multiple alignments on right + output_pairs.append(format_pair( + algns2[-1], + algns2[-2], + pair_index=f"{len(algns1)}r", + algn1_pos3=algns1[-1]["pos5"], + report_position=report_position, + report_orientation=report_orientation + )) + last_reported_alignment_right = 2 # set the pointer for reporting + + # Note that if n_algns1==n_algns2==1 and alignments overlap, then we don't need to check, + # it's a non-ligated DNA fragment that we don't report. + + else: # end alignments do not overlap, report regular pair: + output_pairs.append(format_pair( + algns1[-1], + algns2[-1], + pair_index=f"{len(algns1)}u", + report_position=report_position, + report_orientation=report_orientation + )) + + else: # there was an overlap, set some pointers: + last_reported_alignment_left = last_reported_alignment_right = current_right_pair + + # III. Report all remaining alignments. + # Report all unique alignments on left read (sequential): + for i in range(0, n_algns1 - last_reported_alignment_left): + output_pairs.append(format_pair( + algns1[i], + algns1[i + 1], + pair_index=f"{i + 1}l", + report_position=report_position, + report_orientation=report_orientation + )) + + # Report the pairs where both left alignments overlap right: + for i_overlapping in range(current_right_pair - 1): + idx_left = n_algns1 - current_right_pair + i_overlapping + idx_right = n_algns2 - 1 - i_overlapping + output_pairs.append(format_pair( + algns1[idx_left], + algns1[idx_left + 1], + pair_index=f"{idx_left + 1}b", + algn2_pos3=algns2[idx_right - 1]["pos5"], + report_position=report_position, + report_orientation=report_orientation + )) + + # Report all the sequential chimeric pairs in the right read, but not the overlap: + reporting_order = range(0, min(current_right_pair, n_algns2 - last_reported_alignment_right)) + for i in reporting_order: + # Determine the pair index depending on what is the overlap: + shift = -1 if current_right_pair > 1 else 0 + pair_index = n_algns1 + min(current_right_pair, + n_algns2 - last_reported_alignment_right) - i + shift + output_pairs.append(format_pair( + algns2[i+1], + algns2[i], + pair_index=f"{pair_index}r", + report_position=report_position, + report_orientation=report_orientation + )) + + # Sort the pairs according by the pair index: + walk_length = max([int(x[-1][:-1]) for x in output_pairs]) + # if report_position=="walk": + output_pairs.sort(key=lambda x: int(x[-1][:-1])) + # else: # oder by position to the 5'-end of the read (left or right independently) + # output_pairs.sort(key=lambda x: int(x[-1][:-1]) if x[-1][-1]!='r' else walk_length-int(x[-1][:-1])) + return iter(output_pairs) ### Additional functions for complex walks rescue ### -def ends_do_overlap(algn1, algn2, max_molecule_size=500, allowed_offset=5): +def partial_overlap(algn1, algn2, max_fragment_size=500, allowed_offset=5): """ Two ends of alignments overlap if: 1) they are from the same chromosome, 2) map in the opposite directions, - 3) the distance between the outer ends of the two alignments is below the specified max_molecule_size, + 3) the distance between the outer ends of the two alignments is below the specified max_fragment_size, 4) the distance between the outer ends of the two alignments is above the maximum alignment size. (4) guarantees that the alignments point towards each other on the chromosomes. @@ -704,7 +975,7 @@ def ends_do_overlap(algn1, algn2, max_molecule_size=500, allowed_offset=5): ) distance_outer_ends = algn1["pos5"] - algn2["pos5"] - do_overlap &= distance_outer_ends <= max_molecule_size + allowed_offset + do_overlap &= distance_outer_ends <= max_fragment_size + allowed_offset do_overlap &= distance_outer_ends >= min_algn_size - allowed_offset if do_overlap: @@ -712,104 +983,158 @@ def ends_do_overlap(algn1, algn2, max_molecule_size=500, allowed_offset=5): return 0 -def pairs_do_overlap(algns1, algns2, allowed_offset=5): +def pairs_overlap(algns1, algns2, allowed_offset=3): """ - Forward read: Reverse read: - -----------------------> <------------------------ - algns1 algns2 - 5----------3_5----------3 3----------5_3----------5 - algn1_chim5 algn1_chim3 algn2_chim3 algn2_chim5 - chim_left chim_right chim_left chim_right + We assume algns1 originate from left read, and algns2 originate from right read: + left read: right read: + ----------------------------> <---------------------------- + algns1 algns2 + 5------------3_5------------3 3------------5_3------------5' + left_5'-algn left_3'-algn right_3'-algn right_5'-algn Two pairs of alignments overlap if: - 1) algn1_chim5 and algn2_chim3 originate from the same region (chim_left), - 2) algn1_chim3 and algn2_chim5 originate from the same region (chim_right). - or: - 3) pos3 of algn1_chim5 is close to pos3 of algn2_chim3, - 4) pos5 of algn1_chim3 is close to pos5 of algn2_chim5. + 1) chromosomes/mapping/strand of left_5'-algn and right_3'-algn are the same, + 2) chromosomes/mapping/strand of left_3'-algn and right_5'-algn are the same, + 3) pos3 of left_5'-algn is close to pos5 of right_3'-algn (with allowed_offset), and + 4) pos5 of left_3'-algn is close to pos3 of right_5'-algn. - Return: 1 of the pairs of alignments are overlaps, - 0 if they are not. + Return: 1 of the pairs of alignments overlap, 0 otherwise. """ - - # Some assignments to simplify the code - algn1_chim5 = algns1[0] - algn1_chim3 = algns1[1] - algn2_chim5 = algns2[0] - algn2_chim3 = algns2[1] - - # We assume that successful alignment cannot be an overlap with unmapped or multi-mapped region - mapped_algn1_chim5 = algn1_chim5["is_mapped"] and algn1_chim5["is_unique"] - mapped_algn1_chim3 = algn1_chim3["is_mapped"] and algn1_chim3["is_unique"] - mapped_algn2_chim5 = algn2_chim5["is_mapped"] and algn2_chim5["is_unique"] - mapped_algn2_chim3 = algn2_chim3["is_mapped"] and algn2_chim3["is_unique"] - - if not mapped_algn1_chim5 and not mapped_algn2_chim3: - chim_left_overlap = True - elif not mapped_algn1_chim5 and mapped_algn2_chim3: - chim_left_overlap = False - elif mapped_algn1_chim5 and not mapped_algn2_chim3: - chim_left_overlap = False + left5_algn = algns1[0] + left3_algn = algns1[1] + right5_algn = algns2[0] + right3_algn = algns2[1] + + # We assume that successful alignment cannot be an overlap with unmapped or multi-mapped region: + mapped_left5_algn = left5_algn["is_mapped"] and left5_algn["is_unique"] + mapped_left3_algn = left3_algn["is_mapped"] and left3_algn["is_unique"] + mapped_right5_algn = right5_algn["is_mapped"] and right5_algn["is_unique"] + mapped_right3_algn = right3_algn["is_mapped"] and right3_algn["is_unique"] + + if not mapped_left5_algn and not mapped_right3_algn: + left_overlap = True + elif not mapped_left5_algn and mapped_right3_algn: + left_overlap = False + elif mapped_left5_algn and not mapped_right3_algn: + left_overlap = False else: - chim_left_overlap = True - chim_left_overlap &= algn1_chim5["chrom"] == algn2_chim3["chrom"] - chim_left_overlap &= algn1_chim5["strand"] != algn2_chim3["strand"] - - if not mapped_algn1_chim3 and not mapped_algn2_chim5: - chim_right_overlap = True - elif not mapped_algn1_chim3 and mapped_algn2_chim5: - chim_right_overlap = False - elif mapped_algn1_chim3 and not mapped_algn2_chim5: - chim_right_overlap = False + left_overlap = True + left_overlap &= left5_algn["chrom"] == right3_algn["chrom"] + left_overlap &= left5_algn["strand"] != right3_algn["strand"] + + if not mapped_left3_algn and not mapped_right5_algn: + right_overlap = True + elif not mapped_left3_algn and mapped_right5_algn: + right_overlap = False + elif mapped_left3_algn and not mapped_right5_algn: + right_overlap = False else: - chim_right_overlap = True - chim_right_overlap &= algn1_chim3["chrom"] == algn2_chim5["chrom"] - chim_right_overlap &= algn1_chim3["strand"] != algn2_chim5["strand"] + right_overlap = True + right_overlap &= left3_algn["chrom"] == right5_algn["chrom"] + right_overlap &= left3_algn["strand"] != right5_algn["strand"] - same_junction = True - same_junction &= abs(algn1_chim5["pos3"] - algn2_chim3["pos5"]) <= allowed_offset - same_junction &= abs(algn1_chim3["pos5"] - algn2_chim5["pos3"]) <= allowed_offset + same_pair = True + same_pair &= abs(left5_algn["pos3"] - right3_algn["pos5"]) <= allowed_offset + same_pair &= abs(left3_algn["pos5"] - right5_algn["pos3"]) <= allowed_offset - if chim_left_overlap & chim_right_overlap & same_junction: + if left_overlap & right_overlap & same_pair: return 1 else: return 0 -def _convert_gaps_into_alignments(sorted_algns, max_inter_align_gap): - if (len(sorted_algns) == 1) and (not sorted_algns[0]["is_mapped"]): - return - - last_5_pos = 0 - for i in range(len(sorted_algns)): - algn = sorted_algns[i] - if algn["dist_to_5"] - last_5_pos > max_inter_align_gap: - new_algn = empty_alignment() - new_algn["dist_to_5"] = last_5_pos - new_algn["algn_read_span"] = algn["dist_to_5"] - last_5_pos - new_algn["read_len"] = algn["read_len"] - new_algn["dist_to_3"] = new_algn["read_len"] - algn["dist_to_5"] - - last_5_pos = algn["dist_to_5"] + algn["algn_read_span"] - - sorted_algns.insert(i, new_algn) - i += 2 - else: - last_5_pos = max(last_5_pos, algn["dist_to_5"] + algn["algn_read_span"]) - i += 1 - - -def _mask_alignment(algn): +def format_pair( + hic_algn1, + hic_algn2, + pair_index, + report_position="outer", + report_orientation="pair", + algn1_pos5=None, + algn1_pos3=None, + algn2_pos5=None, + algn2_pos3=None, +): """ - Reset the coordinates of an alignment. + Return a triplet: pair of formatted alignments and pair_index in a walk + + :param hic_algn1: Left alignment forming a pair + :param hic_algn2: Right alignment forming a pair + :param algns1: All left read alignments for formal reporting + :param algns2: All right read alignments for formal reporting + :param pair_index: Index of the pair + :param algn1_pos5: Replace reported 5'-position of the alignment 1 with this value + :param algn1_pos3: Replace reported 3'-position of the alignment 1 with this value + :param algn2_pos5: Replace reported 5'-position of the alignment 2 with this value + :param algn2_pos3: Replace reported 3'-position of the alignment 2 with this value + """ - algn["chrom"] = _pairsam_format.UNMAPPED_CHROM - algn["pos5"] = _pairsam_format.UNMAPPED_POS - algn["pos3"] = _pairsam_format.UNMAPPED_POS - algn["pos"] = _pairsam_format.UNMAPPED_POS - algn["strand"] = _pairsam_format.UNMAPPED_STRAND + # Make sure the original data is not modified: + hic_algn1, hic_algn2 = dict(hic_algn1), dict(hic_algn2) + + # Adjust the 5' and 3'-ends: + hic_algn1["pos5"] = algn1_pos5 if not algn1_pos5 is None else hic_algn1["pos5"] + hic_algn1["pos3"] = algn1_pos3 if not algn1_pos3 is None else hic_algn1["pos3"] + hic_algn2["pos5"] = algn2_pos5 if not algn2_pos5 is None else hic_algn2["pos5"] + hic_algn2["pos3"] = algn2_pos3 if not algn2_pos3 is None else hic_algn2["pos3"] + + hic_algn1["type"] = "N" if not hic_algn1["is_mapped"] else \ + "M" if not hic_algn1["is_unique"] else \ + "U" + + hic_algn2["type"] = "N" if not hic_algn2["is_mapped"] else \ + "M" if not hic_algn2["is_unique"] else \ + "U" + + # Change orientation and positioning of pair for reporting: + # AVAILABLE_REPORT_POSITION = ["outer", "pair", "read", "walk"] + # AVAILABLE_REPORT_ORIENTATION = ["pair", "pair", "read", "walk"] + pair_type = pair_index[-1] + + if report_orientation=="read": + pass + elif report_orientation=="walk": + if pair_type=="r": + hic_algn1 = flip_orientation(hic_algn1) + hic_algn2 = flip_orientation(hic_algn2) + elif pair_type=="u": + hic_algn2 = flip_orientation(hic_algn2) + elif report_orientation=="pair": + if pair_type=="l": + hic_algn2 = flip_orientation(hic_algn2) + elif pair_type == "r": + hic_algn1 = flip_orientation(hic_algn1) + elif report_orientation=="junction": + if pair_type=="l": + hic_algn1 = flip_orientation(hic_algn1) + elif pair_type=="r": + hic_algn2 = flip_orientation(hic_algn2) + else: + hic_algn1 = flip_orientation(hic_algn1) + hic_algn2 = flip_orientation(hic_algn2) + + if report_position=="read": + pass + elif report_position=="walk": + if pair_type=="r": + hic_algn1 = flip_position(hic_algn1) + hic_algn2 = flip_position(hic_algn2) + elif pair_type=="u": + hic_algn2 = flip_position(hic_algn2) + elif report_position=="outer": + if pair_type=="l": + hic_algn2 = flip_position(hic_algn2) + elif pair_type == "r": + hic_algn1 = flip_position(hic_algn1) + elif report_position=="junction": + if pair_type == "l": + hic_algn1 = flip_position(hic_algn1) + elif pair_type == "r": + hic_algn2 = flip_position(hic_algn2) + else: + hic_algn1 = flip_position(hic_algn1) + hic_algn2 = flip_position(hic_algn2) - return algn + return [hic_algn1, hic_algn2, pair_index] def check_pair_order(algn1, algn2, chrom_enum): @@ -821,7 +1146,6 @@ def check_pair_order(algn1, algn2, chrom_enum): # First, the pair is flipped according to the type of mapping on its sides. # Later, we will check it is mapped on both sides and, if so, flip the sides # according to these coordinates. - has_correct_order = (algn1["is_mapped"], algn1["is_unique"]) <= ( algn2["is_mapped"], algn2["is_unique"], @@ -832,7 +1156,6 @@ def check_pair_order(algn1, algn2, chrom_enum): if (algn1["chrom"] != _pairsam_format.UNMAPPED_CHROM) and ( algn2["chrom"] != _pairsam_format.UNMAPPED_CHROM ): - has_correct_order = (chrom_enum[algn1["chrom"]], algn1["pos"]) <= ( chrom_enum[algn2["chrom"]], algn2["pos"], @@ -841,19 +1164,14 @@ def check_pair_order(algn1, algn2, chrom_enum): return has_correct_order -def push_pysam(sam, sams1, sams2): - """Parse pysam AlignedSegment (sam) into pairtools sams entry""" - - flag = sam.flag - - if (flag & 0x40) != 0: - sams1.append(sam) # Forward read, or first read in a pair - else: - sams2.append(sam) # Reverse read, or mate pair - return - +###################### +### Output utilities: +###################### def write_all_algnments(readID, all_algns1, all_algns2, out_file): + """ + Debug utility that outputs all alignments in .bam file before parsing walks/pairs + """ for side_idx, all_algns in enumerate((all_algns1, all_algns2)): out_file.write(readID) out_file.write("\t") @@ -884,18 +1202,19 @@ def write_pairsam( algn1, algn2, readID, - junction_index, + pair_index, sams1, sams2, out_file, drop_readid, drop_seq, drop_sam, - add_junction_index, + add_pair_index, add_columns, ): """ - SAM is already tab-separated and + Write output pairsam. + Note: SAM is already tab-separated and any printable character between ! and ~ may appear in the PHRED field! (http://www.ascii-code.com/) Thus, use the vertical tab character to separate fields! @@ -932,8 +1251,8 @@ def write_pairsam( ) ) - if add_junction_index: - cols.append(junction_index) + if add_pair_index: + cols.append(pair_index) for col in add_columns: # use get b/c empty alignments would not have sam tags (NM, AS, etc) @@ -941,3 +1260,4 @@ def write_pairsam( cols.append(str(algn2.get(col, ""))) out_file.write(_pairsam_format.PAIRSAM_SEP.join(cols) + "\n") + diff --git a/pairtools/_parse_pysam.pyx b/pairtools/_parse_pysam.pyx index 67c8ae23..a65d3ba6 100644 --- a/pairtools/_parse_pysam.pyx +++ b/pairtools/_parse_pysam.pyx @@ -45,3 +45,51 @@ cdef class AlignedSegmentPairtoolized(AlignedSegment): # if 'SA'==tag[0]: # return False return True + + property cigar_dict: + """Parsed CIGAR as dictionary with interpretable fields""" + + def __get__(self): + """Parse cigar tuples reported as cigartuples of pysam read entry. + Reports alignment span, clipped nucleotides and more. + See https://pysam.readthedocs.io/en/latest/api.html#pysam.AlignedSegment.cigartuples + """ + matched_bp = 0 + algn_ref_span = 0 + algn_read_span = 0 + read_len = 0 + clip5_ref = 0 + clip3_ref = 0 + + cigarstring = self.cigarstring + cigartuples = self.cigartuples + if cigartuples is not None: + for operation, length in cigartuples: + if operation == 0: # M, match + matched_bp += length + algn_ref_span += length + algn_read_span += length + read_len += length + elif operation == 1: # I, insertion + algn_read_span += length + read_len += length + elif operation == 2: # D, deletion + algn_ref_span += length + elif ( + operation == 4 or operation == 5 + ): # S and H, soft clip and hard clip, respectively + read_len += length + if matched_bp == 0: + clip5_ref = length + else: + clip3_ref = length + + return { + "clip5_ref": clip5_ref, + "clip3_ref": clip3_ref, + "cigar": cigarstring, + "algn_ref_span": algn_ref_span, + "algn_read_span": algn_read_span, + "read_len": read_len, + "matched_bp": matched_bp, + } diff --git a/pairtools/pairtools_parse.py b/pairtools/pairtools_parse.py index 18e0ef7c..41cbf21b 100644 --- a/pairtools/pairtools_parse.py +++ b/pairtools/pairtools_parse.py @@ -13,6 +13,8 @@ from . import _fileio, _pairsam_format, _parse, _headerops, cli, common_io_options from .pairtools_stats import PairCounter from ._parse_pysam import AlignmentFilePairtoolized +from ._parse import streaming_classify + UTIL_NAME = "pairtools_parse" @@ -71,7 +73,8 @@ show_default=True, help="The maximal size of a Hi-C molecule; used to rescue single ligations" "(from molecules with three alignments) and to rescue complex ligations." - "The default is based on oriented P(s) at short ranges of multiple Hi-C.", + "The default is based on oriented P(s) at short ranges of multiple Hi-C." + "Not used with walks-policy all.", ) @click.option( "--drop-readid", @@ -87,9 +90,9 @@ "--drop-sam", is_flag=True, help="If specified, do not add sams to the output" ) @click.option( - "--add-junction-index", + "--add-pair-index", is_flag=True, - help="If specified, each pair will have junction index in the molecule", + help="If specified, each pair will have pair index in the molecule", ) @click.option( "--add-columns", @@ -172,19 +175,11 @@ def parse( sam_path, chroms_path, output, - assembly, - min_mapq, - max_molecule_size, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns, output_parsed_alignments, output_stats, **kwargs ): - """Find ligation junctions in .sam, make .pairs. + """Find ligation pairs in .sam data, make .pairs. SAM_PATH : an input .sam/.bam file with paired-end sequence alignments of Hi-C molecules. If the path ends with .bam, the input is decompressed from bam with samtools. By default, the input is read from stdin. @@ -193,14 +188,6 @@ def parse( sam_path, chroms_path, output, - assembly, - min_mapq, - max_molecule_size, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns, output_parsed_alignments, output_stats, **kwargs @@ -211,14 +198,6 @@ def parse_py( sam_path, chroms_path, output, - assembly, - min_mapq, - max_molecule_size, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns, output_parsed_alignments, output_stats, **kwargs @@ -254,6 +233,7 @@ def parse_py( out_stat = PairCounter() if output_stats else None ### Set up output parameters + add_columns = kwargs.get("add_columns", []) add_columns = [col for col in add_columns.split(",") if col] for col in add_columns: if not ((col in EXTRA_COLUMNS) or (len(col) == 2 and col.isupper())): @@ -263,12 +243,12 @@ def parse_py( [c + side for c in add_columns for side in ["1", "2"]] ) - if drop_sam: + if kwargs.get("drop_sam", True): columns.pop(columns.index("sam1")) columns.pop(columns.index("sam2")) - if not add_junction_index: - columns.pop(columns.index("junction_index")) + if not kwargs.get("add_pair_index", False): + columns.pop(columns.index("pair_index")) ### Parse header samheader = input_sam.header @@ -284,7 +264,7 @@ def parse_py( ### Write new header to the pairsam file header = _headerops.make_standard_pairsheader( - assembly=assembly, + assembly=kwargs.get("assembly", ""), chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], columns=columns, shape="whole matrix" if kwargs["no_flip"] else "upper triangle", @@ -299,13 +279,6 @@ def parse_py( input_sam, outstream, chromosomes, - min_mapq, - max_molecule_size, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns, out_alignments_stream, out_stat, **kwargs @@ -324,125 +297,5 @@ def parse_py( out_stats_stream.close() -def streaming_classify( - instream, - outstream, - chromosomes, - min_mapq, - max_molecule_size, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns, - out_alignments_stream, - out_stat, - **kwargs -): - """ - Parse input sam file and write to the outstream(s) - """ - - ### Store output parameters in usable form: - chrom_enum = dict( - zip( - [_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), - range(len(chromosomes) + 1), - ) - ) - sam_tags = [col for col in add_columns if len(col) == 2 and col.isupper()] - store_seq = "seq" in add_columns - - ### Create temporary variables that will be populated by parsing reads at each iteration over input: - prev_readID = "" # Placeholder for the read id - sams1 = [] # Placeholder for the left alignments - sams2 = [] # Placeholder for the right alignments - aligned_segment = "" # Placeholder for each aligned segment - - ### Compile readID transformation if requested: - readID_transform = kwargs.get("readid_transform", None) - if readID_transform is not None: - readID_transform = compile(readID_transform, "", "eval") - - ### Iterate over the input pysam: - instream = iter(instream) - while aligned_segment is not None: - aligned_segment = next( - instream, None - ) # required for proper parsing of the last read - - readID = aligned_segment.query_name if aligned_segment else None - if readID_transform is not None and readID is not None: - readID = eval(readID_transform) - - # Perform parsing and writing when all the segments are parsed from the read: - if not (aligned_segment) or ((readID != prev_readID) and prev_readID): - - for ( - algn1, - algn2, - all_algns1, - all_algns2, - junction_index, - ) in _parse.parse_sams_into_pair( - sams1, - sams2, - min_mapq, - max_molecule_size, - kwargs["max_inter_align_gap"], - kwargs["walks_policy"], - kwargs["report_alignment_end"] == "3", - sam_tags, - store_seq - ): - - flip_pair = (not kwargs["no_flip"]) and ( - not _parse.check_pair_order(algn1, algn2, chrom_enum) - ) - - if flip_pair: - algn1, algn2 = algn2, algn1 - sams1, sams2 = sams2, sams1 - - _parse.write_pairsam( - algn1, - algn2, - prev_readID, - junction_index, - sams1, - sams2, - outstream, - drop_readid, - drop_seq, - drop_sam, - add_junction_index, - add_columns - ) - - # add a pair to PairCounter if stats output is requested: - if out_stat: - out_stat.add_pair( - algn1["chrom"], - int(algn1["pos"]), - algn1["strand"], - algn2["chrom"], - int(algn2["pos"]), - algn2["strand"], - algn1["type"] + algn2["type"], - ) - - if out_alignments_stream: - _parse.write_all_algnments( - prev_readID, all_algns1, all_algns2, out_alignments_stream - ) - - sams1.clear() - sams2.clear() - - if aligned_segment is not None: - _parse.push_pysam(aligned_segment, sams1, sams2) - prev_readID = readID - - if __name__ == "__main__": parse() diff --git a/pairtools/pairtools_parse2.py b/pairtools/pairtools_parse2.py new file mode 100644 index 00000000..03fba264 --- /dev/null +++ b/pairtools/pairtools_parse2.py @@ -0,0 +1,333 @@ +# !/usr/bin/env python +# -*- coding: utf-8 -*- + +from collections import OrderedDict +import subprocess +import fileinput +import itertools +import click +import pipes +import sys +import os +import io +import pysam + +from . import _fileio, _pairsam_format, _parse, _headerops, cli, common_io_options +from .pairtools_stats import PairCounter +from ._parse_pysam import AlignmentFilePairtoolized +from ._parse import streaming_classify + +UTIL_NAME = "pairtools_parse2" + +EXTRA_COLUMNS = [ + "mapq", + "pos5", + "pos3", + "cigar", + "read_len", + "matched_bp", + "algn_ref_span", + "algn_read_span", + "dist_to_5", + "dist_to_3", + "seq", +] + + +@cli.command() +@click.argument("sam_path", type=str, required=False) +# Parsing options: +@click.option( + "-c", + "--chroms-path", + type=str, + required=True, + help="Chromosome order used to flip interchromosomal mates: " + "path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose " + "first column lists scaffold names. Any scaffolds not listed will be " + "ordered lexicographically following the names provided.", +) +@click.option( + "-o", + "--output", + type=str, + default="", + help="output file. " + " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." + "By default, the output is printed into stdout. ", +) +@click.option( + "--report-position", + type=click.Choice(["junction", "read", "walk", "outer"]), + default="outer", + help="Specifies what end will be reported as pos5 of the rescued pairs. " + "junction - inner ends of sequential alignments, " + "read - 5'-end of alignments relative to the forward and reverse read, " + "walk - 5'-end of alignments relative to the whole walk, " + "outer - outer ends. " +) +@click.option( + "--report-orientation", + type=click.Choice(["pair", "read", "walk", "junction"]), + default="pair", + help="Specifies what orientation will be reported for the rescued pairs. " + "pair - Hi-C-like orientation as if each pair was sequenced independently, " + "read - orientation of each left/right read, " + "walk - orientation of the walk, " + "junction - orientation opposite to 'pair', orientation is reported as if pair was sequenced starting from the junction" +) +@click.option( + "--report-alignment-end", + type=click.Choice(["5", "3"]), + default="5", + help="Specifies whether the 5' or 3' end of the alignment is reported as" + " the position of the Hi-C read.", +) +@click.option( + "--assembly", + type=str, + help="Name of genome assembly (e.g. hg19, mm10) to store in the pairs header.", +) +@click.option( + "--min-mapq", + type=int, + default=1, + show_default=True, + help="The minimal MAPQ score to consider a read as uniquely mapped", +) +@click.option( + "--max-inter-align-gap", + type=int, + default=20, + show_default=True, + help="read segments that are not covered by any alignment and" + ' longer than the specified value are treated as "null" alignments.' + " These null alignments convert otherwise linear alignments into walks," + " and affect how they get reported as a Hi-C pair.", +) +@click.option( + "--max-fragment-size", + type=int, + default=500, + show_default=True, + help="Largest fragment size for the detection of overlapping " + "alignments at the ends of forward and reverse reads. " + "Not used in --single-end mode. ", +) +@click.option( + "--allowed-offset", + type=int, + default=3, + show_default=True, + help="Offset (in nucleotides) to consider alignments overlapping. ", +) +@click.option( + "--single-end", is_flag=True, help="If specified, the input is single-end." +) +@click.option( + "--no-flip", + is_flag=True, + help="If specified, do not flip pairs in genomic order and instead preserve " + "the order in which they were sequenced.", +) +@click.option( + "--drop-readid", + is_flag=True, + help="If specified, do not add read ids to the output", +) +@click.option( + "--readid-transform", + type=str, + default=None, + help="A Python expression to modify read IDs. Useful when read IDs differ " + "between the two reads of a pair. Must be a valid Python expression that " + "uses variables called readID and/or i (the 0-based index of the read pair " + "in the bam file) and returns a new value, e.g. \"readID[:-2]+'_'+str(i)\". " + "Make sure that transformed readIDs remain unique!", + show_default=True, +) +@click.option( + "--drop-seq", + is_flag=True, + help="If specified, remove sequences and PHREDs from the sam fields", +) +@click.option( + "--drop-sam", is_flag=True, help="If specified, do not add sams to the output" +) +@click.option( + "--add-pair-index", + is_flag=True, + help="If specified, parse2 will report pair index in the walk as additional column", +) +@click.option( + "--add-columns", + type=click.STRING, + default="", + help="Report extra columns describing alignments " + "Possible values (can take multiple values as a comma-separated " + "list): a SAM tag (any pair of uppercase letters) or {}.".format( + ", ".join(EXTRA_COLUMNS) + ), +) +@click.option( + "--output-parsed-alignments", + type=str, + default="", + help="output file for all parsed alignments, including walks." + " Useful for debugging and rnalysis of walks." + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." + " By default, not used.", +) +@click.option( + "--output-stats", + type=str, + default="", + help="output file for various statistics of pairs file. " + " By default, statistics is not generated.", +) +@common_io_options +def parse2( + sam_path, + chroms_path, + output, + output_parsed_alignments, + output_stats, + **kwargs +): + """Find pairs in .sam data, make .pairs. + SAM_PATH : an input .sam/.bam file with paired-end sequence alignments of + Hi-C molecules. If the path ends with .bam, the input is decompressed from + bam with samtools. By default, the input is read from stdin. + """ + parse2_py( + sam_path, + chroms_path, + output, + output_parsed_alignments, + output_stats, + **kwargs + ) + + +def parse2_py( + sam_path, + chroms_path, + output, + output_parsed_alignments, + output_stats, + **kwargs +): + ### Set up input stream + if sam_path: # open input sam file with pysam + input_sam = AlignmentFilePairtoolized(sam_path, "r", threads=kwargs.get('nproc_in')) + else: # read from stdin + input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get('nproc_in')) + + ### Set up output streams + outstream = ( + _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + out_alignments_stream = ( + _fileio.auto_open( + output_parsed_alignments, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output_parsed_alignments + else None + ) + out_stats_stream = ( + _fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output_stats + else None + ) + + if out_alignments_stream: + out_alignments_stream.write( + "readID\tside\tchrom\tpos\tstrand\tmapq\tcigar\tdist_5_lo\tdist_5_hi\tmatched_bp\n" + ) + + # generate empty PairCounter if stats output is requested: + out_stat = PairCounter() if output_stats else None + + ### Set up output parameters + add_columns = kwargs.get("add_columns", []) + add_columns = [col for col in add_columns.split(",") if col] + for col in add_columns: + if not ((col in EXTRA_COLUMNS) or (len(col) == 2 and col.isupper())): + raise Exception("{} is not a valid extra column".format(col)) + + columns = _pairsam_format.COLUMNS + ( + [c + side for c in add_columns for side in ["1", "2"]] + ) + + if kwargs.get("drop_sam", True): + columns.pop(columns.index("sam1")) + columns.pop(columns.index("sam2")) + + if not kwargs.get("add_pair_index", False): + columns.pop(columns.index("pair_index")) + + ### Parse header + samheader = input_sam.header + + if not samheader: + raise ValueError( + "The input sam is missing a header! If reading a bam file, please use `samtools view -h` to include the header." + ) + + ### Parse chromosome files present in the input + sam_chromsizes = _headerops.get_chromsizes_from_pysam_header(samheader) + chromosomes = _headerops.get_chrom_order(chroms_path, list(sam_chromsizes.keys())) + + ### Write new header to the pairsam file + header = _headerops.make_standard_pairsheader( + assembly=kwargs.get("assembly", ""), + chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], + columns=columns, + shape="whole matrix" if kwargs["no_flip"] else "upper triangle", + ) + + header = _headerops.insert_samheader_pysam(header, samheader) + header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + outstream.writelines((l + "\n" for l in header)) + + ### Parse input and write to the outputs + streaming_classify( + input_sam, + outstream, + chromosomes, + out_alignments_stream, + out_stat, + parse2=True, + **kwargs + ) + + # save statistics to a file if it was requested: + if out_stat: + out_stat.save(out_stats_stream) + + if outstream != sys.stdout: + outstream.close() + if out_alignments_stream: + out_alignments_stream.close() + if out_stats_stream: + out_stats_stream.close() + + +if __name__ == "__main__": + parse2() diff --git a/tests/data/mock.parse-all.sam b/tests/data/mock.parse-all.sam index f8bace0d..c5766397 100644 --- a/tests/data/mock.parse-all.sam +++ b/tests/data/mock.parse-all.sam @@ -31,26 +31,26 @@ readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u -readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1f -readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1f -readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1f -readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|chr1,200,chr1,5324,+,-,UU,2u -readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|chr1,200,chr1,5324,+,-,UU,2u -readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|chr1,200,chr1,5324,+,-,UU,2u -readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,200,chr1,300,+,+,UU,2u -readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,200,chr1,300,+,+,UU,2u -readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,200,chr1,300,+,+,UU,2u -readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1f -readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1f -readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2000,+,+,UU,3r -readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2000,+,+,UU,3r -readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2000,+,+,UU,3r -readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1f|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2000,+,+,UU,3r -readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,NU,2u -readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,NU,2u -readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,NU,2u -readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,MU,2u -readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,MU,2u -readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5324,+,-,UU,1f|!,0,chr1,5324,-,-,MU,2u +readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,200,chr1,300,+,+,UU,2u +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,200,chr1,300,+,+,UU,2u +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1l|chr1,200,chr1,300,+,+,UU,2u +readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1u diff --git a/tests/data/mock.parse2.sam b/tests/data/mock.parse2.sam new file mode 100644 index 00000000..dac50e20 --- /dev/null +++ b/tests/data/mock.parse2.sam @@ -0,0 +1,56 @@ +@SQ SN:chr1 LN:10000 +@SQ SN:chr2 LN:10000 +@PG ID:mock PN:mock VN:0.0.0 CL:mock +readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u +readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u +readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u +readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u +readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u +readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u +readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u +readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u +readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u +readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u +readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u +readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u +readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u +readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u +readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u +readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u +readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u +readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u +readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u +readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u +readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u +readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u +readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u +readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u +readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u +readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u +readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u +readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u +readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u +readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u +readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u +readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,MU,2u +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1l|!,0,chr1,5300,-,-,MU,2u +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1l|!,0,chr1,5300,-,-,MU,2u +readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1u diff --git a/tests/test_parse.py b/tests/test_parse.py index f91c3495..896343bc 100644 --- a/tests/test_parse.py +++ b/tests/test_parse.py @@ -72,7 +72,7 @@ def test_mock_pysam_parse_all(): "all", "-c", mock_chroms_path, - "--add-junction-index", + "--add-pair-index", mock_sam_path, ], ).decode("ascii") @@ -112,3 +112,4 @@ def test_mock_pysam_parse_all(): print() assert assigned_pair == simulated_pair + diff --git a/tests/test_parse2.py b/tests/test_parse2.py new file mode 100644 index 00000000..7acc37f6 --- /dev/null +++ b/tests/test_parse2.py @@ -0,0 +1,111 @@ +# -*- coding: utf-8 -*- +import os +import sys + +from nose.tools import assert_raises + +import subprocess + +testdir = os.path.dirname(os.path.realpath(__file__)) + + +def test_mock_pysam_parse2_read(): + mock_sam_path = os.path.join(testdir, 'data', 'mock.parse2.sam') + mock_chroms_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') + try: + result = subprocess.check_output( + ['python', + '-m', + 'pairtools', + 'parse2', + '-c', + mock_chroms_path, + '--add-pair-index', + '--report-position', + 'junction', + '--report-orientation', + 'pair', + mock_sam_path], + ).decode('ascii') + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check if the header got transferred correctly + sam_header = [l.strip() for l in open(mock_sam_path, 'r') if l.startswith('@')] + pairsam_header = [l.strip() for l in result.split('\n') if l.startswith('#')] + for l in sam_header: + assert any([l in l2 for l2 in pairsam_header]) + + # check that the pairs got assigned properly + id_counter = 0 + prev_id = '' + for l in result.split('\n'): + if l.startswith('#') or not l: + continue + + if prev_id == l.split('\t')[0]: + id_counter += 1 + else: + id_counter = 0 + prev_id = l.split('\t')[0] + + assigned_pair = l.split('\t')[1:8]+[l.split('\t')[-1]] + simulated_pair = l.split('SIMULATED:',1)[1].split('\031',1)[0].split('|')[id_counter].split(',') + print(assigned_pair) + print(simulated_pair, prev_id) + print() + + assert assigned_pair == simulated_pair + + +def test_mock_pysam_parse2_pair(): + mock_sam_path = os.path.join(testdir, 'data', 'mock.parse-all.sam') + mock_chroms_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') + try: + result = subprocess.check_output( + ['python', + '-m', + 'pairtools', + 'parse2', + '-c', + mock_chroms_path, + '--add-pair-index', + '--report-position', + 'outer', + '--report-orientation', + 'pair', + mock_sam_path], + ).decode('ascii') + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check if the header got transferred correctly + sam_header = [l.strip() for l in open(mock_sam_path, 'r') if l.startswith('@')] + pairsam_header = [l.strip() for l in result.split('\n') if l.startswith('#')] + for l in sam_header: + assert any([l in l2 for l2 in pairsam_header]) + + # check that the pairs got assigned properly + id_counter = 0 + prev_id = '' + for l in result.split('\n'): + if l.startswith('#') or not l: + continue + + if prev_id == l.split('\t')[0]: + id_counter += 1 + else: + id_counter = 0 + prev_id = l.split('\t')[0] + + assigned_pair = l.split('\t')[1:8]+[l.split('\t')[-1]] + simulated_pair = l.split('SIMULATED:',1)[1].split('\031',1)[0].split('|')[id_counter].split(',') + print(assigned_pair) + print(simulated_pair, prev_id) + print() + + assert assigned_pair == simulated_pair From fed4699117e683011586987c9d2b48034936e519 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Mon, 11 Apr 2022 18:32:43 -0400 Subject: [PATCH 07/52] black --- pairtools/__init__.py | 88 ++-- pairtools/__main__.py | 2 +- pairtools/_fileio.py | 226 ++++++----- pairtools/_headerops.py | 5 +- pairtools/_pairsam_format.py | 32 +- pairtools/_parse.py | 390 +++++++++++------- pairtools/pairtools_dedup.py | 9 +- pairtools/pairtools_filterbycov.py | 626 ++++++++++++++++++----------- pairtools/pairtools_flip.py | 139 ++++--- pairtools/pairtools_markasdup.py | 96 +++-- pairtools/pairtools_merge.py | 275 +++++++------ pairtools/pairtools_parse.py | 61 ++- pairtools/pairtools_parse2.py | 85 ++-- pairtools/pairtools_phase.py | 202 +++++----- pairtools/pairtools_restrict.py | 134 +++--- pairtools/pairtools_sample.py | 89 ++-- pairtools/pairtools_select.py | 186 +++++---- pairtools/pairtools_sort.py | 169 ++++---- pairtools/pairtools_split.py | 119 +++--- pairtools/pairtools_stats.py | 37 +- tests/test_dedup.py | 197 +++++---- tests/test_filterbycov.py | 153 +++---- tests/test_flip.py | 73 ++-- tests/test_headerops.py | 140 +++---- tests/test_markasdup.py | 30 +- tests/test_merge.py | 141 ++++--- tests/test_parse.py | 1 - tests/test_parse2.py | 114 +++--- tests/test_restrict.py | 11 +- tests/test_select.py | 238 ++++++----- tests/test_sort.py | 58 +-- tests/test_split.py | 97 +++-- tests/test_stats.py | 65 ++- 33 files changed, 2364 insertions(+), 1924 deletions(-) diff --git a/pairtools/__init__.py b/pairtools/__init__.py index 9d019b53..281a75a2 100644 --- a/pairtools/__init__.py +++ b/pairtools/__init__.py @@ -11,7 +11,7 @@ """ -__version__ = '0.3.1-dev.1' +__version__ = "0.3.1-dev.1" import click @@ -19,49 +19,48 @@ import sys CONTEXT_SETTINGS = { - 'help_option_names': ['-h', '--help'], + "help_option_names": ["-h", "--help"], } @click.version_option(version=__version__) @click.group(context_settings=CONTEXT_SETTINGS) @click.option( - '--post-mortem', - help="Post mortem debugging", - is_flag=True, - default=False + "--post-mortem", help="Post mortem debugging", is_flag=True, default=False ) - @click.option( - '--output-profile', + "--output-profile", help="Profile performance with Python cProfile and dump the statistics " - "into a binary file", + "into a binary file", type=str, - default='' + default="", ) def cli(post_mortem, output_profile): - '''Flexible tools for Hi-C data processing. + """Flexible tools for Hi-C data processing. - All pairtools have a few common options, which should be typed _before_ + All pairtools have a few common options, which should be typed _before_ the command name. - ''' + """ if post_mortem: import traceback + try: import ipdb as pdb except ImportError: import pdb + def _excepthook(exc_type, value, tb): traceback.print_exception(exc_type, value, tb) print() pdb.pm() + sys.excepthook = _excepthook if output_profile: - import cProfile + import cProfile import atexit - + pr = cProfile.Profile() pr.enable() @@ -74,45 +73,46 @@ def _atexit_profile_hook(): def common_io_options(func): @click.option( - '--nproc-in', - type=int, - default=3, + "--nproc-in", + type=int, + default=3, show_default=True, - help='Number of processes used by the auto-guessed input decompressing command.' - ) + help="Number of processes used by the auto-guessed input decompressing command.", + ) @click.option( - '--nproc-out', - type=int, - default=8, + "--nproc-out", + type=int, + default=8, show_default=True, - help='Number of processes used by the auto-guessed output compressing command.' - ) + help="Number of processes used by the auto-guessed output compressing command.", + ) @click.option( - '--cmd-in', - type=str, - default=None, - help='A command to decompress the input file. ' - 'If provided, fully overrides the auto-guessed command. ' - 'Does not work with stdin and pairtools parse. ' - 'Must read input from stdin and print output into stdout. ' - 'EXAMPLE: pbgzip -dc -n 3' - ) + "--cmd-in", + type=str, + default=None, + help="A command to decompress the input file. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdin and pairtools parse. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -dc -n 3", + ) @click.option( - '--cmd-out', - type=str, - default=None, - help='A command to compress the output file. ' - 'If provided, fully overrides the auto-guessed command. ' - 'Does not work with stdout. ' - 'Must read input from stdin and print output into stdout. ' - 'EXAMPLE: pbgzip -c -n 8' - ) - + "--cmd-out", + type=str, + default=None, + help="A command to compress the output file. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdout. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -c -n 8", + ) @functools.wraps(func) def wrapper(*args, **kwargs): return func(*args, **kwargs) + return wrapper + from .pairtools_dedup import dedup from .pairtools_sort import sort from .pairtools_flip import flip diff --git a/pairtools/__main__.py b/pairtools/__main__.py index 35fdb6c1..7c4a768c 100644 --- a/pairtools/__main__.py +++ b/pairtools/__main__.py @@ -1,4 +1,4 @@ from . import cli -if __name__=='__main__': +if __name__ == "__main__": cli() diff --git a/pairtools/_fileio.py b/pairtools/_fileio.py index 81d5f663..2bd5f467 100644 --- a/pairtools/_fileio.py +++ b/pairtools/_fileio.py @@ -3,139 +3,150 @@ import subprocess import sys + class ParseError(Exception): pass + def auto_open(path, mode, nproc=1, command=None): - '''Guess the file format from the extension and use the corresponding binary + """Guess the file format from the extension and use the corresponding binary to open it for reading or writing. If the extension is not known, open the file as text. - If the binary allows parallel execution, specify the number of threads + If the binary allows parallel execution, specify the number of threads with `nproc`. If `command` is supplied, use it to open the file instead of auto-guessing. - The command must accept the filename as the last argument, accept input + The command must accept the filename as the last argument, accept input through stdin and print output into stdout. Supported extensions and binaries (with comments): .bam - samtools view (allows parallel writing) - .gz - pbgzip if available, otherwise bgzip + .gz - pbgzip if available, otherwise bgzip .lz4 - lz4c (does not support parallel execution) - ''' + """ # Empty filepath or False provided - if not path or path=="-": - if mode=="r": + if not path or path == "-": + if mode == "r": return sys.stdin - if mode=="w": + if mode == "w": return sys.stdout if command: - if mode =='w': + if mode == "w": t = pipes.Template() - t.append(command, '--') - f = t.open(path, 'w') - elif mode =='r': + t.append(command, "--") + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append(command, '--') - f = t.open(path, 'r') + t.append(command, "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode : {}".format(mode)) return f - elif path.endswith('.bam'): - if shutil.which('samtools') is None: - raise ValueError({ - 'w':'samtools is not found, cannot compress output', - 'r':'samtools is not found, cannot decompress input' - }[mode]) - if mode =='w': + elif path.endswith(".bam"): + if shutil.which("samtools") is None: + raise ValueError( + { + "w": "samtools is not found, cannot compress output", + "r": "samtools is not found, cannot decompress input", + }[mode] + ) + if mode == "w": t = pipes.Template() - t.append('samtools view -bS {} -'.format( - '-@ '+str(nproc-1) if nproc>1 else ''), - '--') - f = t.open(path, 'w') - elif mode =='r': + t.append( + "samtools view -bS {} -".format( + "-@ " + str(nproc - 1) if nproc > 1 else "" + ), + "--", + ) + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append('samtools view -h', '--') - f = t.open(path, 'r') + t.append("samtools view -h", "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode for .bam : {}".format(mode)) return f - elif path.endswith('.gz'): - if shutil.which('pbgzip') is not None: - if mode =='w': + elif path.endswith(".gz"): + if shutil.which("pbgzip") is not None: + if mode == "w": t = pipes.Template() - t.append('pbgzip -c -n {}'.format(nproc), '--') - f = t.open(path, 'w') - elif mode =='a': + t.append("pbgzip -c -n {}".format(nproc), "--") + f = t.open(path, "w") + elif mode == "a": t = pipes.Template() - t.append('pbgzip -c -n {} $IN >> $OUT'.format(nproc), 'ff') - f = t.open(path, 'w') - elif mode =='r': + t.append("pbgzip -c -n {} $IN >> $OUT".format(nproc), "ff") + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append('pbgzip -dc -n {}'.format(nproc), '--') - f = t.open(path, 'r') + t.append("pbgzip -dc -n {}".format(nproc), "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode for .gz : {}".format(mode)) - elif shutil.which('bgzip') is not None: - if mode =='w': + elif shutil.which("bgzip") is not None: + if mode == "w": t = pipes.Template() - t.append('bgzip -c -@ {}'.format(nproc), '--') - f = t.open(path, 'w') - elif mode =='a': + t.append("bgzip -c -@ {}".format(nproc), "--") + f = t.open(path, "w") + elif mode == "a": t = pipes.Template() - t.append('bgzip -c -@ {} $IN >> $OUT'.format(nproc), 'ff') - f = t.open(path, 'w') - elif mode =='r': + t.append("bgzip -c -@ {} $IN >> $OUT".format(nproc), "ff") + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append('bgzip -dc -@ {}'.format(nproc), '--') - f = t.open(path, 'r') + t.append("bgzip -dc -@ {}".format(nproc), "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode for .gz : {}".format(mode)) - elif shutil.which('gzip') is not None: - if mode =='w': + elif shutil.which("gzip") is not None: + if mode == "w": t = pipes.Template() - t.append('gzip -c', '--') - f = t.open(path, 'w') - elif mode =='a': + t.append("gzip -c", "--") + f = t.open(path, "w") + elif mode == "a": t = pipes.Template() - t.append('gzip -c $IN >> $OUT', 'ff') - f = t.open(path, 'w') - elif mode =='r': + t.append("gzip -c $IN >> $OUT", "ff") + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append('gzip -dc', '--') - f = t.open(path, 'r') + t.append("gzip -dc", "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode for .gz : {}".format(mode)) else: - raise ValueError({ - 'w':'pbgzip, bgzip and gzip are not found, cannot compress output', - 'a':'pbgzip, bgzip and gzip are is not found, cannot compress output', - 'r':'pbgzip, bgzip and gzip are is not found, cannot decompress input' - }[mode]) + raise ValueError( + { + "w": "pbgzip, bgzip and gzip are not found, cannot compress output", + "a": "pbgzip, bgzip and gzip are is not found, cannot compress output", + "r": "pbgzip, bgzip and gzip are is not found, cannot decompress input", + }[mode] + ) return f - elif path.endswith('.lz4'): - if shutil.which('lz4c') is None: - raise ValueError({ - 'w':'lz4c is not found, cannot compress output', - 'a':'lz4c is not found, cannot compress output', - 'r':'lz4c is not found, cannot decompress input' - }[mode]) - if mode =='w': + elif path.endswith(".lz4"): + if shutil.which("lz4c") is None: + raise ValueError( + { + "w": "lz4c is not found, cannot compress output", + "a": "lz4c is not found, cannot compress output", + "r": "lz4c is not found, cannot decompress input", + }[mode] + ) + if mode == "w": t = pipes.Template() - t.append('lz4c -cz', '--') - f = t.open(path, 'w') - elif mode =='a': + t.append("lz4c -cz", "--") + f = t.open(path, "w") + elif mode == "a": t = pipes.Template() - t.append('lz4c -cz $IN >> $OUT', 'ff') - f = t.open(path, 'w') - elif mode =='r': + t.append("lz4c -cz $IN >> $OUT", "ff") + f = t.open(path, "w") + elif mode == "r": t = pipes.Template() - t.append('lz4c -cd', '--') - f = t.open(path, 'r') + t.append("lz4c -cd", "--") + f = t.open(path, "r") else: raise ValueError("Unknown mode : {}".format(mode)) return f @@ -144,49 +155,63 @@ def auto_open(path, mode, nproc=1, command=None): class PipedIO: - def __init__(self, file_or_path, command, mode='r'): + def __init__(self, file_or_path, command, mode="r"): """ - An experimental class that reads/writes a file, piping the contents + An experimental class that reads/writes a file, piping the contents through another process. Parameters ---------- file_or_path : file-like object or str - A path to the input/output file or an already opened + A path to the input/output file or an already opened file-like object. command : str A command to launch a reading/writing process. If mode is 'w', the process must accept input via stdin. If mode is 'r', the process must put output into stdout. - If mode is 'r' and file_or_path is str, the path will be - appended to the command as the last argument. + If mode is 'r' and file_or_path is str, the path will be + appended to the command as the last argument. mode : str The mode for opening, same as in open(mode=). Returns ------- - file: a file-like object + file: a file-like object """ if issubclass(type(command), str): - command = command.split(' ') + command = command.split(" ") self._command = command self._mode = mode - - if mode.startswith('r'): + + if mode.startswith("r"): if issubclass(type(file_or_path), str): - self._proc = subprocess.Popen(command + [file_or_path], universal_newlines=True, stdout=subprocess.PIPE) + self._proc = subprocess.Popen( + command + [file_or_path], + universal_newlines=True, + stdout=subprocess.PIPE, + ) else: - self._proc = subprocess.Popen(command, universal_newlines=True, stdin=file_or_path, stdout=subprocess.PIPE) + self._proc = subprocess.Popen( + command, + universal_newlines=True, + stdin=file_or_path, + stdout=subprocess.PIPE, + ) self._stream = self._proc.stdout - + self._close_stream = self._proc.stdout.close - - elif mode.startswith('w') or mode.startswith('a'): - f = open(file_or_path, mode=mode) if issubclass(type(file_or_path), str) else file_or_path - self._proc = subprocess.Popen(command, universal_newlines=True, stdin=subprocess.PIPE, stdout=f) - self._stream = self._proc.stdin + elif mode.startswith("w") or mode.startswith("a"): + f = ( + open(file_or_path, mode=mode) + if issubclass(type(file_or_path), str) + else file_or_path + ) + self._proc = subprocess.Popen( + command, universal_newlines=True, stdin=subprocess.PIPE, stdout=f + ) + self._stream = self._proc.stdin self.buffer = self._stream.buffer self.closed = self._stream.closed @@ -196,8 +221,7 @@ def __init__(self, file_or_path, command, mode='r'): self.read = self._stream.read self.readline = self._stream.readline self.readlines = self._stream.readlines - - + self.seek = self._stream.seek self.seekable = self._stream.seekable self.truncate = self._stream.truncate @@ -206,10 +230,8 @@ def __init__(self, file_or_path, command, mode='r'): self.writable = self._stream.writable self.write = self._stream.write self.writelines = self._stream.writelines - - + def close(self, timeout=None): self._stream.close() retcode = self._proc.wait(timeout=timeout) return retcode - diff --git a/pairtools/_headerops.py b/pairtools/_headerops.py index aef871f6..54746f09 100644 --- a/pairtools/_headerops.py +++ b/pairtools/_headerops.py @@ -15,6 +15,7 @@ SEP_COLS = " " SEP_CHROMS = " " + def get_header(instream, comment_char="#"): """Returns a header from the stream and an the reaminder of the stream with the actual data. @@ -606,7 +607,8 @@ def _merge_pairheaders(pairheaders, force=False): for h in pairheaders for l in h if not any( - l.startswith(k) for k in keys_expected_identical + ["#chromosomes", "#chromsize"] + l.startswith(k) + for k in keys_expected_identical + ["#chromosomes", "#chromsize"] ) ) ) @@ -658,6 +660,7 @@ def append_columns(header, columns): header[i] += SEP_COLS + SEP_COLS.join(columns) return header + # def _guess_genome_assembly(samheader): # PG = [l for l in samheader if l.startswith('@PG') and '\tID:bwa' in l][0] # CL = [field for field in PG.split('\t') if field.startswith('CL:')] diff --git a/pairtools/_pairsam_format.py b/pairtools/_pairsam_format.py index 77ec1f3a..2cd14244 100644 --- a/pairtools/_pairsam_format.py +++ b/pairtools/_pairsam_format.py @@ -1,10 +1,10 @@ -PAIRSAM_FORMAT_VERSION = '1.0.0' +PAIRSAM_FORMAT_VERSION = "1.0.0" -PAIRSAM_SEP = '\t' -PAIRSAM_SEP_ESCAPE = r'\t' -SAM_SEP = '\031' -SAM_SEP_ESCAPE = r'\031' -INTER_SAM_SEP = '\031NEXT_SAM\031' +PAIRSAM_SEP = "\t" +PAIRSAM_SEP_ESCAPE = r"\t" +SAM_SEP = "\031" +SAM_SEP_ESCAPE = r"\031" +INTER_SAM_SEP = "\031NEXT_SAM\031" COL_READID = 0 COL_C1 = 1 @@ -17,12 +17,22 @@ COL_SAM1 = 8 COL_SAM2 = 9 -COLUMNS = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', - 'strand1', 'strand2', 'pair_type', 'sam1', 'sam2', - 'pair_index'] +COLUMNS = [ + "readID", + "chrom1", + "pos1", + "chrom2", + "pos2", + "strand1", + "strand2", + "pair_type", + "sam1", + "sam2", + "pair_index", +] -UNMAPPED_CHROM = '!' +UNMAPPED_CHROM = "!" UNMAPPED_POS = 0 -UNMAPPED_STRAND = '-' +UNMAPPED_STRAND = "-" UNANNOTATED_RFRAG = -1 diff --git a/pairtools/_parse.py b/pairtools/_parse.py index 36f905ff..c6778d4a 100644 --- a/pairtools/_parse.py +++ b/pairtools/_parse.py @@ -37,13 +37,9 @@ from . import _pairsam_format + def streaming_classify( - instream, - outstream, - chromosomes, - out_alignments_stream, - out_stat, - **kwargs + instream, outstream, chromosomes, out_alignments_stream, out_stat, **kwargs ): """ Parse input sam file into individual reads, pairs, walks, @@ -79,7 +75,7 @@ def streaming_classify( range(len(chromosomes) + 1), ) ) - add_columns = kwargs.get("add_columns", "").split(',') + add_columns = kwargs.get("add_columns", "").split(",") sam_tags = [col for col in add_columns if len(col) == 2 and col.isupper()] store_seq = "seq" in add_columns @@ -90,7 +86,7 @@ def streaming_classify( ### Prepare for iterative parsing of the input stream # Each read is represented by readID, sams1 (left alignments) and sams2 (right alignments) - readID = "" # Read id of the current read + readID = "" # Read id of the current read sams1 = [] # Placeholder for the left alignments sams2 = [] # Placeholder for the right alignments # Each read is comprised of multiple alignments, or sam entries: @@ -111,7 +107,7 @@ def streaming_classify( if not (sam_entry) or ((readID != prev_readID) and prev_readID): ### Parse - if not parse2: # regular parser: + if not parse2: # regular parser: pairstream, all_algns1, all_algns2 = parse_read( sams1, sams2, @@ -120,7 +116,7 @@ def streaming_classify( max_inter_align_gap=kwargs["max_inter_align_gap"], walks_policy=kwargs["walks_policy"], sam_tags=sam_tags, - store_seq=store_seq + store_seq=store_seq, ) else: # parse2 parser: pairstream, all_algns1, all_algns2 = parse2_read( @@ -134,7 +130,7 @@ def streaming_classify( report_orientation=kwargs["report_orientation"], sam_tags=sam_tags, allowed_offset=kwargs["allowed_offset"], - store_seq=store_seq + store_seq=store_seq, ) ### Write: @@ -167,7 +163,7 @@ def streaming_classify( drop_seq=kwargs["drop_seq"], drop_sam=kwargs["drop_sam"], add_pair_index=kwargs["add_pair_index"], - add_columns=kwargs["add_columns"] + add_columns=kwargs["add_columns"], ) # add a pair to PairCounter for stats output: @@ -201,6 +197,7 @@ def streaming_classify( ### Alignment utilities: ### ############################ + def push_pysam(sam_entry, sams1, sams2): """Parse pysam AlignedSegment (sam) into pairtools sams entry""" flag = sam_entry.flag @@ -210,6 +207,7 @@ def push_pysam(sam_entry, sams1, sams2): sams2.append(sam_entry) # right read, or mate pair return + def empty_alignment(): return { "chrom": _pairsam_format.UNMAPPED_CHROM, @@ -233,6 +231,7 @@ def empty_alignment(): "type": "N", } + def parse_pysam_entry( sam, min_mapq, sam_tags=None, store_seq=False, report_3_alignment_end=False ): @@ -321,6 +320,7 @@ def parse_pysam_entry( return algn + def mask_alignment(algn): """ Reset the coordinates of an alignment. @@ -333,6 +333,7 @@ def mask_alignment(algn): return algn + def flip_alignment(hic_algn): """ Flip a single alignment as if it was sequenced from the opposite end @@ -344,6 +345,7 @@ def flip_alignment(hic_algn): hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" return hic_algn + def flip_orientation(hic_algn): """ Flip orientation of a single alignment @@ -354,6 +356,7 @@ def flip_orientation(hic_algn): hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" return hic_algn + def flip_position(hic_algn): """ Flip ends of a single alignment @@ -369,6 +372,7 @@ def flip_position(hic_algn): ### Parsing utilities: #################### + def parse_read( sams1, sams2, @@ -377,7 +381,7 @@ def parse_read( max_inter_align_gap, walks_policy, sam_tags, - store_seq + store_seq, ): """ Parse sam entries corresponding to a single read (or Hi-C molecule) @@ -405,8 +409,8 @@ def parse_read( return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments - algns1 = [ parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1 ] - algns2 = [ parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2 ] + algns1 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1] + algns2 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2] algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) algns2 = sorted(algns2, key=lambda algn: algn["dist_to_5"]) @@ -430,11 +434,19 @@ def parse_read( # Report all the linear alignments in a read pair if walks_policy == "all": # Report linear alignments after deduplication of complex walks with default settings: - return parse_complex_walk(algns1, algns2, max_molecule_size, - report_position="outer", - report_orientation="pair"), algns1, algns2 + return ( + parse_complex_walk( + algns1, + algns2, + max_molecule_size, + report_position="outer", + report_orientation="pair", + ), + algns1, + algns2, + ) - elif walks_policy in ['mask', '5any', '5unique', '3any', '3unique']: + elif walks_policy in ["mask", "5any", "5unique", "3any", "3unique"]: # Report only two alignments for a read pair rescued_linear_side = rescue_walk(algns1, algns2, max_molecule_size) @@ -509,7 +521,7 @@ def parse2_read( report_orientation="pair", sam_tags=[], allowed_offset=3, - store_seq=False + store_seq=False, ): """ Parse sam entries corresponding to a Hi-C molecule into alignments in parse2 mode @@ -529,7 +541,9 @@ def parse2_read( # Single-end mode: if single_end: # Generate a sorted, gap-filled list of all alignments - algns1 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1] + algns1 = [ + parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1 + ] algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) if max_inter_align_gap is not None: _convert_gaps_into_alignments(algns1, max_inter_align_gap) @@ -539,14 +553,23 @@ def parse2_read( if len(algns1) > 1: # Look for ligation pair, and report linear alignments after deduplication of complex walks: # (Note that coordinate system for single-end reads does not change the behavior) - return parse_complex_walk( - algns1, algns2, max_fragment_size, report_position, report_orientation, allowed_offset - ), algns1, algns2 + return ( + parse_complex_walk( + algns1, + algns2, + max_fragment_size, + report_position, + report_orientation, + allowed_offset, + ), + algns1, + algns2, + ) else: # If no additional information, we assume each molecule is a single ligation with single unconfirmed pair: algn2 = algns2[0] if report_orientation == "walk": - algn2 = flip_orientation(algn2) + algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) return iter([(algns1[0], algn2, "1u")]), algns1, algns2 @@ -562,8 +585,12 @@ def parse2_read( return iter([(algns1[0], algns2[0], "1u")]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments - algns1 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1] - algns2 = [parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2] + algns1 = [ + parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams1 + ] + algns2 = [ + parse_pysam_entry(sam, min_mapq, sam_tags, store_seq) for sam in sams2 + ] algns1 = sorted(algns1, key=lambda algn: algn["dist_to_5"]) algns2 = sorted(algns2, key=lambda algn: algn["dist_to_5"]) @@ -578,14 +605,22 @@ def parse2_read( if is_chimeric_1 or is_chimeric_2: # If at least one side is chimera, we must look for ligation pair, and # report linear alignments after deduplication of complex walks: - return parse_complex_walk( - algns1, algns2, max_fragment_size, report_position, report_orientation - ), algns1, algns2 + return ( + parse_complex_walk( + algns1, + algns2, + max_fragment_size, + report_position, + report_orientation, + ), + algns1, + algns2, + ) else: # If no additional information, we assume each molecule is a single ligation with single unconfirmed pair: algn2 = algns2[0] if report_orientation == "walk": - algn2 = flip_orientation(algn2) + algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) return iter([(algns1[0], algn2, "1u")]), algns1, algns2 @@ -595,6 +630,7 @@ def parse2_read( ### Walks utilities: #################### + def rescue_walk(algns1, algns2, max_molecule_size): """ Rescue a single ligation that appears as a walk. @@ -680,7 +716,7 @@ def rescue_walk(algns1, algns2, max_molecule_size): can_rescue &= molecule_size <= max_molecule_size if can_rescue: - # changing the type of the 3' alignment on side 1, does not show up in the output: + # changing the type of the 3' alignment on side 1, does not show up in the output: if first_read_is_chimeric: algns1[1]["type"] = "X" @@ -694,6 +730,7 @@ def rescue_walk(algns1, algns2, max_molecule_size): else: return None + def _convert_gaps_into_alignments(sorted_algns, max_inter_align_gap): """ Inplace conversion of gaps longer than max_inter_align_gap into alignments @@ -726,11 +763,11 @@ def parse_complex_walk( max_fragment_size, report_position, report_orientation, - allowed_offset=3 + allowed_offset=3, ): """ - Parse a set of ligations that appear as a complex walk. - This procedure is equivalent to intramolecular deduplication that preserved pair order in a walk. + Parse a set of ligations that appear as a complex walk. + This procedure is equivalent to intramolecular deduplication that preserved pair order in a walk. :param algns1: List of sequential lefts alignments :param algns2: List of sequential right alignments @@ -750,42 +787,42 @@ def parse_complex_walk( l0 l1 l2 l3 r3 r2 r1 r0 Alignment - bwa mem reported hit or alignment after gaps conversion. - Left and right alignments (algns1: [l0, l1, l2, l3], algns2: [r0, r1, r2, r3]) - - alignments on left and right reads reported from 5' to 3' orientation. - - Intramolecular deduplication consists of two steps: + Left and right alignments (algns1: [l0, l1, l2, l3], algns2: [r0, r1, r2, r3]) + - alignments on left and right reads reported from 5' to 3' orientation. + + Intramolecular deduplication consists of two steps: I. iterative search of overlapping alignment pairs (aka overlap), - II. if no overlaps or search not possible (less than 2 alignments on either sides), - search for overlap of end alignments (aka partial overlap). - III. report pairs before the overlap, deduplicated pairs of overlap and pairs after that. - - Iterative search of overlap is in fact scanning of the right read pairs for the hit - with the 3'-most pair of the left read: - 1. Initialize. + II. if no overlaps or search not possible (less than 2 alignments on either sides), + search for overlap of end alignments (aka partial overlap). + III. report pairs before the overlap, deduplicated pairs of overlap and pairs after that. + + Iterative search of overlap is in fact scanning of the right read pairs for the hit + with the 3'-most pair of the left read: + 1. Initialize. Start from 3' of left and right reads. Set `current_left_pair` and `current_right_pair` pointers - 2. Initial compare. + 2. Initial compare. Compare pairs l2-l3 and r3-r2 by `pairs_overlap`. If successful, we found the overlap, go to reporting. If unsuccessful, continue search. - 3. Increment. - Shift `current_right_pair` pointer by one (e.g., take the pair r2-r1). - 4. Check. + 3. Increment. + Shift `current_right_pair` pointer by one (e.g., take the pair r2-r1). + 4. Check. Check that this pair can form a potential overlap with left alignments: the number of pairs downstream from l2-l3 on left read should not be less than the number of pairs upstream from r2-r1 on right read. If overlap cannot be formed, no other overlap in this complex walk is possible, safely exit. If the potential overlap can be formed, continue comparison. - 5. Compare. + 5. Compare. Compare the current pair of pairs on left and right reads. If comparison fails, go to step 3. - If comparison is successful, go to 6. - 6. Verify. + If comparison is successful, go to 6. + 6. Verify. Check that downstream pairs on the left read overlap with the upstream pairs on the right read. If yes, exit. If not, we do not have an overlap, go to step 3. """ - AVAILABLE_REPORT_POSITION = ["outer", "junction", "read", "walk"] + AVAILABLE_REPORT_POSITION = ["outer", "junction", "read", "walk"] assert report_position in AVAILABLE_REPORT_POSITION, ( f"Cannot report position {report_position}, as it is not implemented" f'Available choices are: {", ".join(AVAILABLE_REPORT_POSITION)}' @@ -797,22 +834,30 @@ def parse_complex_walk( f'Available choices are: {", ".join(AVAILABLE_REPORT_ORIENTATION)}' ) - output_pairs = [] - + output_pairs = [] + # Initialize (step 1). n_algns1 = len(algns1) n_algns2 = len(algns2) - current_left_pair = current_right_pair = 1 - remaining_left_pairs = n_algns1 - 1 # Number of possible pairs remaining on left read - remaining_right_pairs = n_algns2 - 1 # Number of possible pairs remaining on right read - checked_right_pairs = 0 # Number of checked pairs on right read (from the end of read) + current_left_pair = current_right_pair = 1 + remaining_left_pairs = ( + n_algns1 - 1 + ) # Number of possible pairs remaining on left read + remaining_right_pairs = ( + n_algns2 - 1 + ) # Number of possible pairs remaining on right read + checked_right_pairs = ( + 0 # Number of checked pairs on right read (from the end of read) + ) is_overlap = False # I. Iterative search of overlap, at least two alignments on each side: if (n_algns1 >= 2) and (n_algns2 >= 2): # Iteration includes check (step 4): - while (remaining_left_pairs > checked_right_pairs) and (remaining_right_pairs > 0): - pair1 = (algns1[-current_left_pair - 1], algns1[-current_left_pair] ) + while (remaining_left_pairs > checked_right_pairs) and ( + remaining_right_pairs > 0 + ): + pair1 = (algns1[-current_left_pair - 1], algns1[-current_left_pair]) pair2 = (algns2[-current_right_pair - 1], algns2[-current_right_pair]) # Compare (initial or not, step 2 or 5): is_overlap = pairs_overlap(pair1, pair2, allowed_offset=allowed_offset) @@ -824,11 +869,19 @@ def parse_complex_walk( while is_overlap and (checked_right_temp > 0): last_idx_left_temp += 1 last_idx_right_temp -= 1 - pair1 = (algns1[-last_idx_left_temp - 1], algns1[-last_idx_left_temp]) - pair2 = (algns2[-last_idx_right_temp - 1], algns2[-last_idx_right_temp]) - is_overlap &= pairs_overlap(pair1, pair2, allowed_offset=allowed_offset) + pair1 = ( + algns1[-last_idx_left_temp - 1], + algns1[-last_idx_left_temp], + ) + pair2 = ( + algns2[-last_idx_right_temp - 1], + algns2[-last_idx_right_temp], + ) + is_overlap &= pairs_overlap( + pair1, pair2, allowed_offset=allowed_offset + ) checked_right_temp -= 1 - if is_overlap: # exit + if is_overlap: # exit current_right_pair += 1 break @@ -844,82 +897,111 @@ def parse_complex_walk( # II. Search of partial overlap if there are less than 2 alignments at either sides, or no overlaps found if current_right_pair == 1: last_reported_alignment_left = last_reported_alignment_right = 1 - if partial_overlap(algns1[-1], algns2[-1], max_fragment_size=max_fragment_size, allowed_offset=allowed_offset): - if (n_algns1 >= 2): # single alignment on right read and multiple alignments on left - output_pairs.append(format_pair( - algns1[-2], - algns1[-1], - pair_index=f"{len(algns1)-1}l", - algn2_pos3=algns2[-1]["pos5"], - report_position=report_position, - report_orientation=report_orientation - )) - last_reported_alignment_left = 2 # set the pointer for reporting - - if (n_algns2 >= 2): # single alignment on left read and multiple alignments on right - output_pairs.append(format_pair( - algns2[-1], - algns2[-2], - pair_index=f"{len(algns1)}r", - algn1_pos3=algns1[-1]["pos5"], - report_position=report_position, - report_orientation=report_orientation - )) - last_reported_alignment_right = 2 # set the pointer for reporting + if partial_overlap( + algns1[-1], + algns2[-1], + max_fragment_size=max_fragment_size, + allowed_offset=allowed_offset, + ): + if ( + n_algns1 >= 2 + ): # single alignment on right read and multiple alignments on left + output_pairs.append( + format_pair( + algns1[-2], + algns1[-1], + pair_index=f"{len(algns1)-1}l", + algn2_pos3=algns2[-1]["pos5"], + report_position=report_position, + report_orientation=report_orientation, + ) + ) + last_reported_alignment_left = 2 # set the pointer for reporting + + if ( + n_algns2 >= 2 + ): # single alignment on left read and multiple alignments on right + output_pairs.append( + format_pair( + algns2[-1], + algns2[-2], + pair_index=f"{len(algns1)}r", + algn1_pos3=algns1[-1]["pos5"], + report_position=report_position, + report_orientation=report_orientation, + ) + ) + last_reported_alignment_right = 2 # set the pointer for reporting # Note that if n_algns1==n_algns2==1 and alignments overlap, then we don't need to check, # it's a non-ligated DNA fragment that we don't report. - - else: # end alignments do not overlap, report regular pair: - output_pairs.append(format_pair( - algns1[-1], - algns2[-1], - pair_index=f"{len(algns1)}u", - report_position=report_position, - report_orientation=report_orientation - )) - else: # there was an overlap, set some pointers: - last_reported_alignment_left = last_reported_alignment_right = current_right_pair + else: # end alignments do not overlap, report regular pair: + output_pairs.append( + format_pair( + algns1[-1], + algns2[-1], + pair_index=f"{len(algns1)}u", + report_position=report_position, + report_orientation=report_orientation, + ) + ) - # III. Report all remaining alignments. + else: # there was an overlap, set some pointers: + last_reported_alignment_left = ( + last_reported_alignment_right + ) = current_right_pair + + # III. Report all remaining alignments. # Report all unique alignments on left read (sequential): for i in range(0, n_algns1 - last_reported_alignment_left): - output_pairs.append(format_pair( - algns1[i], - algns1[i + 1], - pair_index=f"{i + 1}l", - report_position=report_position, - report_orientation=report_orientation - )) + output_pairs.append( + format_pair( + algns1[i], + algns1[i + 1], + pair_index=f"{i + 1}l", + report_position=report_position, + report_orientation=report_orientation, + ) + ) # Report the pairs where both left alignments overlap right: for i_overlapping in range(current_right_pair - 1): idx_left = n_algns1 - current_right_pair + i_overlapping idx_right = n_algns2 - 1 - i_overlapping - output_pairs.append(format_pair( - algns1[idx_left], - algns1[idx_left + 1], - pair_index=f"{idx_left + 1}b", - algn2_pos3=algns2[idx_right - 1]["pos5"], - report_position=report_position, - report_orientation=report_orientation - )) + output_pairs.append( + format_pair( + algns1[idx_left], + algns1[idx_left + 1], + pair_index=f"{idx_left + 1}b", + algn2_pos3=algns2[idx_right - 1]["pos5"], + report_position=report_position, + report_orientation=report_orientation, + ) + ) # Report all the sequential chimeric pairs in the right read, but not the overlap: - reporting_order = range(0, min(current_right_pair, n_algns2 - last_reported_alignment_right)) + reporting_order = range( + 0, min(current_right_pair, n_algns2 - last_reported_alignment_right) + ) for i in reporting_order: # Determine the pair index depending on what is the overlap: shift = -1 if current_right_pair > 1 else 0 - pair_index = n_algns1 + min(current_right_pair, - n_algns2 - last_reported_alignment_right) - i + shift - output_pairs.append(format_pair( - algns2[i+1], - algns2[i], - pair_index=f"{pair_index}r", - report_position=report_position, - report_orientation=report_orientation - )) + pair_index = ( + n_algns1 + + min(current_right_pair, n_algns2 - last_reported_alignment_right) + - i + + shift + ) + output_pairs.append( + format_pair( + algns2[i + 1], + algns2[i], + pair_index=f"{pair_index}r", + report_position=report_position, + report_orientation=report_orientation, + ) + ) # Sort the pairs according by the pair index: walk_length = max([int(x[-1][:-1]) for x in output_pairs]) @@ -1077,55 +1159,63 @@ def format_pair( hic_algn2["pos5"] = algn2_pos5 if not algn2_pos5 is None else hic_algn2["pos5"] hic_algn2["pos3"] = algn2_pos3 if not algn2_pos3 is None else hic_algn2["pos3"] - hic_algn1["type"] = "N" if not hic_algn1["is_mapped"] else \ - "M" if not hic_algn1["is_unique"] else \ - "U" + hic_algn1["type"] = ( + "N" + if not hic_algn1["is_mapped"] + else "M" + if not hic_algn1["is_unique"] + else "U" + ) - hic_algn2["type"] = "N" if not hic_algn2["is_mapped"] else \ - "M" if not hic_algn2["is_unique"] else \ - "U" + hic_algn2["type"] = ( + "N" + if not hic_algn2["is_mapped"] + else "M" + if not hic_algn2["is_unique"] + else "U" + ) # Change orientation and positioning of pair for reporting: # AVAILABLE_REPORT_POSITION = ["outer", "pair", "read", "walk"] # AVAILABLE_REPORT_ORIENTATION = ["pair", "pair", "read", "walk"] pair_type = pair_index[-1] - if report_orientation=="read": + if report_orientation == "read": pass - elif report_orientation=="walk": - if pair_type=="r": + elif report_orientation == "walk": + if pair_type == "r": hic_algn1 = flip_orientation(hic_algn1) hic_algn2 = flip_orientation(hic_algn2) - elif pair_type=="u": + elif pair_type == "u": hic_algn2 = flip_orientation(hic_algn2) - elif report_orientation=="pair": - if pair_type=="l": + elif report_orientation == "pair": + if pair_type == "l": hic_algn2 = flip_orientation(hic_algn2) elif pair_type == "r": hic_algn1 = flip_orientation(hic_algn1) - elif report_orientation=="junction": - if pair_type=="l": + elif report_orientation == "junction": + if pair_type == "l": hic_algn1 = flip_orientation(hic_algn1) - elif pair_type=="r": + elif pair_type == "r": hic_algn2 = flip_orientation(hic_algn2) else: hic_algn1 = flip_orientation(hic_algn1) hic_algn2 = flip_orientation(hic_algn2) - if report_position=="read": + if report_position == "read": pass - elif report_position=="walk": - if pair_type=="r": + elif report_position == "walk": + if pair_type == "r": hic_algn1 = flip_position(hic_algn1) hic_algn2 = flip_position(hic_algn2) - elif pair_type=="u": + elif pair_type == "u": hic_algn2 = flip_position(hic_algn2) - elif report_position=="outer": - if pair_type=="l": + elif report_position == "outer": + if pair_type == "l": hic_algn2 = flip_position(hic_algn2) elif pair_type == "r": hic_algn1 = flip_position(hic_algn1) - elif report_position=="junction": + elif report_position == "junction": if pair_type == "l": hic_algn1 = flip_position(hic_algn1) elif pair_type == "r": @@ -1168,6 +1258,7 @@ def check_pair_order(algn1, algn2, chrom_enum): ### Output utilities: ###################### + def write_all_algnments(readID, all_algns1, all_algns2, out_file): """ Debug utility that outputs all alignments in .bam file before parsing walks/pairs @@ -1234,8 +1325,8 @@ def write_pairsam( for sams in [sams1, sams2]: if drop_seq: for sam in sams: - sam.query_qualities = '' - sam.query_sequence = '' + sam.query_qualities = "" + sam.query_sequence = "" cols.append( _pairsam_format.INTER_SAM_SEP.join( [ @@ -1260,4 +1351,3 @@ def write_pairsam( cols.append(str(algn2.get(col, ""))) out_file.write(_pairsam_format.PAIRSAM_SEP.join(cols) + "\n") - diff --git a/pairtools/pairtools_dedup.py b/pairtools/pairtools_dedup.py index c2f472d0..6e36898c 100644 --- a/pairtools/pairtools_dedup.py +++ b/pairtools/pairtools_dedup.py @@ -401,8 +401,8 @@ def dedup_py( outstream.writelines((l + "\n" for l in header)) if send_header_to_dup and outstream_dups and (outstream_dups != outstream): dups_header = header - if keep_parent_id and len(dups_header)>0: - dups_header= _headerops.append_columns(dups_header, ["parent_readID"]) + if keep_parent_id and len(dups_header) > 0: + dups_header = _headerops.append_columns(dups_header, ["parent_readID"]) outstream_dups.writelines((l + "\n" for l in dups_header)) if ( outstream_unmapped @@ -704,7 +704,10 @@ def _dedup_chunk( if N_mapped > 0: if backend == "sklearn": a = neighbors.radius_neighbors_graph( - df_mapped[["pos1", "pos2"]], radius=r, p=p, n_jobs=n_proc, + df_mapped[["pos1", "pos2"]], + radius=r, + p=p, + n_jobs=n_proc, ) a0, a1 = a.nonzero() elif backend == "scipy": diff --git a/pairtools/pairtools_filterbycov.py b/pairtools/pairtools_filterbycov.py index 69ec19d0..a1f595d0 100644 --- a/pairtools/pairtools_filterbycov.py +++ b/pairtools/pairtools_filterbycov.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- import sys -import ast +import ast import warnings import pathlib @@ -13,236 +13,334 @@ from .pairtools_markasdup import mark_split_pair_as_dup from .pairtools_stats import PairCounter -UTIL_NAME = 'pairtools_filterbycov' +UTIL_NAME = "pairtools_filterbycov" ###################################### ## TODO: - output stats after filtering ## edit/update mark as dup to mark as multi ################################### + @cli.command() -@click.argument( - 'pairs_path', - type=str, - required=False) +@click.argument("pairs_path", type=str, required=False) @click.option( - "-o", "--output", - type=str, - default="", - help='output file for pairs from low coverage regions.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, the output is printed into stdout.') + "-o", + "--output", + type=str, + default="", + help="output file for pairs from low coverage regions." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) @click.option( "--output-highcov", - type=str, - default="", - help='output file for pairs from high coverage regions.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' If the path is the same as in --output or -, output duplicates together ' - ' with deduped pairs. By default, duplicates are dropped.') + type=str, + default="", + help="output file for pairs from high coverage regions." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " If the path is the same as in --output or -, output duplicates together " + " with deduped pairs. By default, duplicates are dropped.", +) @click.option( "--output-unmapped", - type=str, - default="", - help='output file for unmapped pairs. ' - 'If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. ' - 'If the path is the same as in --output or -, output unmapped pairs together ' - 'with deduped pairs. If the path is the same as --output-highcov, ' - 'output unmapped reads together. By default, unmapped pairs are dropped.') + type=str, + default="", + help="output file for unmapped pairs. " + "If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. " + "If the path is the same as in --output or -, output unmapped pairs together " + "with deduped pairs. If the path is the same as --output-highcov, " + "output unmapped reads together. By default, unmapped pairs are dropped.", +) @click.option( - "--output-stats", - type=str, - default="", - help='output file for statistics of multiple interactors. ' - ' If file exists, it will be open in the append mode.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, statistics are not printed.') + "--output-stats", + type=str, + default="", + help="output file for statistics of multiple interactors. " + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, statistics are not printed.", +) @click.option( - "--max-cov", - type=int, - default=8, - help='The maximum allowed coverage per region.' - ) + "--max-cov", type=int, default=8, help="The maximum allowed coverage per region." +) @click.option( "--max-dist", - type=int, + type=int, default=500, - help='The resolution for calculating coverage. For each pair, the local ' - 'coverage around each end is calculated as (1 + the number of neighbouring ' - 'pairs within +/- max_dist bp) ') + help="The resolution for calculating coverage. For each pair, the local " + "coverage around each end is calculated as (1 + the number of neighbouring " + "pairs within +/- max_dist bp) ", +) @click.option( - '--method', - type=click.Choice(['max', 'sum']), - default="max", - help='calculate the number of neighbouring pairs as either the sum or the max' - ' of the number of neighbours on the two sides', - show_default=True) + "--method", + type=click.Choice(["max", "sum"]), + default="max", + help="calculate the number of neighbouring pairs as either the sum or the max" + " of the number of neighbours on the two sides", + show_default=True, +) @click.option( "--sep", - type=str, - default=_pairsam_format.PAIRSAM_SEP_ESCAPE, - help=r"Separator (\t, \v, etc. characters are " - "supported, pass them in quotes) ") + type=str, + default=_pairsam_format.PAIRSAM_SEP_ESCAPE, + help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", +) @click.option( - "--comment-char", - type=str, - default="#", - help="The first character of comment lines") + "--comment-char", type=str, default="#", help="The first character of comment lines" +) @click.option( - "--send-header-to", - type=click.Choice(['lowcov', 'highcov', 'both', 'none']), - default="both", - help="Which of the outputs should receive header and comment lines") + "--send-header-to", + type=click.Choice(["lowcov", "highcov", "both", "none"]), + default="both", + help="Which of the outputs should receive header and comment lines", +) @click.option( - "--c1", - type=int, - default=_pairsam_format.COL_C1, - help='Chrom 1 column; default {}'.format(_pairsam_format.COL_C1)) + "--c1", + type=int, + default=_pairsam_format.COL_C1, + help="Chrom 1 column; default {}".format(_pairsam_format.COL_C1), +) @click.option( - "--c2", - type=int, - default=_pairsam_format.COL_C2, - help='Chrom 2 column; default {}'.format(_pairsam_format.COL_C2)) + "--c2", + type=int, + default=_pairsam_format.COL_C2, + help="Chrom 2 column; default {}".format(_pairsam_format.COL_C2), +) @click.option( - "--p1", - type=int, - default=_pairsam_format.COL_P1, - help='Position 1 column; default {}'.format(_pairsam_format.COL_P1)) + "--p1", + type=int, + default=_pairsam_format.COL_P1, + help="Position 1 column; default {}".format(_pairsam_format.COL_P1), +) @click.option( - "--p2", - type=int, - default=_pairsam_format.COL_P2, - help='Position 2 column; default {}'.format(_pairsam_format.COL_P2)) + "--p2", + type=int, + default=_pairsam_format.COL_P2, + help="Position 2 column; default {}".format(_pairsam_format.COL_P2), +) @click.option( - "--s1", - type=int, - default=_pairsam_format.COL_S1, - help='Strand 1 column; default {}'.format(_pairsam_format.COL_S1)) + "--s1", + type=int, + default=_pairsam_format.COL_S1, + help="Strand 1 column; default {}".format(_pairsam_format.COL_S1), +) @click.option( - "--s2", - type=int, - default=_pairsam_format.COL_S2, - help='Strand 2 column; default {}'.format(_pairsam_format.COL_S2)) + "--s2", + type=int, + default=_pairsam_format.COL_S2, + help="Strand 2 column; default {}".format(_pairsam_format.COL_S2), +) @click.option( - "--unmapped-chrom", - type=str, - default=_pairsam_format.UNMAPPED_CHROM, - help='Placeholder for a chromosome on an unmapped side; default {}'.format(_pairsam_format.UNMAPPED_CHROM)) + "--unmapped-chrom", + type=str, + default=_pairsam_format.UNMAPPED_CHROM, + help="Placeholder for a chromosome on an unmapped side; default {}".format( + _pairsam_format.UNMAPPED_CHROM + ), +) @click.option( - "--mark-multi", + "--mark-multi", is_flag=True, help='If specified, duplicate pairs are marked as FF in "pair_type" and ' - 'as a duplicate in the sam entries.') - + "as a duplicate in the sam entries.", +) @common_io_options - def filterbycov( - pairs_path, output, output_highcov, - output_unmapped, output_stats, - max_dist,max_cov, method, - sep, comment_char, send_header_to, - c1, c2, p1, p2, s1, s2, unmapped_chrom, mark_multi, **kwargs - ): - '''Remove pairs from regions of high coverage. - + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, + **kwargs +): + """Remove pairs from regions of high coverage. + Find and remove pairs with >(MAX_COV-1) neighbouring pairs - within a +/- MAX_DIST bp window around either side. Useful for single-cell - Hi-C experiments, where coverage is naturally limited by the chromosome + within a +/- MAX_DIST bp window around either side. Useful for single-cell + Hi-C experiments, where coverage is naturally limited by the chromosome copy number. PAIRS_PATH : input triu-flipped sorted .pairs or .pairsam file. If the - path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. + path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - ''' + """ filterbycov_py( - pairs_path, output, output_highcov, - output_unmapped,output_stats, - max_dist,max_cov, method, - sep, comment_char, send_header_to, - c1, c2, p1, p2, s1, s2, unmapped_chrom, mark_multi, + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, **kwargs - ) - - + ) + + def filterbycov_py( - pairs_path, output, output_highcov, - output_unmapped, output_stats, - max_dist,max_cov, method, - sep, comment_char, send_header_to, - c1, c2, p1, p2, s1, s2, unmapped_chrom, mark_multi, + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, **kwargs - ): - - +): + ## Prepare input, output streams based on selected outputs ## Default ouput stream is low-frequency interactors sep = ast.literal_eval('"""' + sep + '"""') - send_header_to_lowcov = send_header_to in ['both', 'lowcov'] - send_header_to_highcov = send_header_to in ['both', 'highcov'] - - instream = (_fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) - out_stats_stream = (_fileio.auto_open(output_stats, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output_stats else None) + send_header_to_lowcov = send_header_to in ["both", "lowcov"] + send_header_to_highcov = send_header_to in ["both", "highcov"] + + instream = ( + _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + out_stats_stream = ( + _fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output_stats + else None + ) # generate empty PairCounter if stats output is requested: - out_stat = PairCounter() if output_stats else None - + out_stat = PairCounter() if output_stats else None + # output the high-frequency interacting pairs if not output_highcov: outstream_high = None - elif (output_highcov == '-' or - (pathlib.Path(output_highcov).absolute() == pathlib.Path(output).absolute())): + elif output_highcov == "-" or ( + pathlib.Path(output_highcov).absolute() == pathlib.Path(output).absolute() + ): outstream_high = outstream else: - outstream_high = _fileio.auto_open(output_highcov, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - + outstream_high = _fileio.auto_open( + output_highcov, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + # output unmapped pairs if not output_unmapped: outstream_unmapped = None - elif (output_unmapped == '-' or - (pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute())): + elif output_unmapped == "-" or ( + pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute() + ): outstream_unmapped = outstream - elif (pathlib.Path(output_unmapped).absolute() == pathlib.Path(output_highcov).absolute()): + elif ( + pathlib.Path(output_unmapped).absolute() + == pathlib.Path(output_highcov).absolute() + ): outstream_unmapped = outstream_high else: - outstream_unmapped = _fileio.auto_open(output_unmapped, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - + outstream_unmapped = _fileio.auto_open( + output_unmapped, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + # prepare file headers header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) # header for low-frequency interactors if send_header_to_lowcov: - outstream.writelines((l+'\n' for l in header)) - + outstream.writelines((l + "\n" for l in header)) + # header for high-frequency interactors if send_header_to_highcov and outstream_high and (outstream_high != outstream): - outstream_high.writelines((l+'\n' for l in header)) - + outstream_high.writelines((l + "\n" for l in header)) + # header for unmapped pairs - if (outstream_unmapped and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_high)): - outstream_unmapped.writelines((l+'\n' for l in header)) - + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_high) + ): + outstream_unmapped.writelines((l + "\n" for l in header)) + # perform filtering of pairs based on low/high-frequency of interaction - streaming_filterbycov( method, max_dist,max_cov, sep, - c1, c2, p1, p2, s1, s2, unmapped_chrom, - body_stream, outstream, outstream_high, - outstream_unmapped, out_stat, mark_multi) - + streaming_filterbycov( + method, + max_dist, + max_cov, + sep, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + body_stream, + outstream, + outstream_high, + outstream_unmapped, + out_stat, + mark_multi, + ) + ## FINISHED! # save statistics to a file if it was requested: TO BE TESTED if out_stat: @@ -257,20 +355,24 @@ def filterbycov_py( if outstream_high and (outstream_high != outstream): outstream_high.close() - if (outstream_unmapped and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_high)): + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_high) + ): outstream_unmapped.close() if out_stats_stream: out_stats_stream.close() - - + + def fetchadd(key, mydict): key = key.strip() if key not in mydict: mydict[key] = len(mydict) return mydict[key] + def ar(mylist, val): return np.array(mylist, dtype={8: np.int8, 16: np.int16, 32: np.int32}[val]) @@ -281,28 +383,31 @@ def _filterbycov(c1_in, p1_in, c2_in, p2_in, max_dist, method): Use cythonized version in the future!! """ - c1 = np.asarray(c1_in,dtype=int) - p1 = np.asarray(p1_in,dtype=int) - c2 = np.asarray(c2_in,dtype=int) - p2 = np.asarray(p2_in,dtype=int) - - M = np.r_[np.c_[c1,p1],np.c_[c2,p2]] # M is a table of (chrom, pos) with 2*N rows + c1 = np.asarray(c1_in, dtype=int) + p1 = np.asarray(p1_in, dtype=int) + c2 = np.asarray(c2_in, dtype=int) + p2 = np.asarray(p2_in, dtype=int) + + M = np.r_[ + np.c_[c1, p1], np.c_[c2, p2] + ] # M is a table of (chrom, pos) with 2*N rows - assert (c1.shape[0] == c2.shape[0]) - N = 2*c1.shape[0] + assert c1.shape[0] == c2.shape[0] + N = 2 * c1.shape[0] - ind_sorted = np.lexsort((M[:,1],M[:,0])) # sort by chromosomes, then positions + ind_sorted = np.lexsort((M[:, 1], M[:, 0])) # sort by chromosomes, then positions # M[ind_sorted] # ind_sorted # M, M[ind_sorted] - - if (method == 'sum'): - proximity_count = np.zeros(N) # keeps track of how many molecules each framgent end is close to - elif (method == 'max'): - proximity_count = np.zeros(N) + if method == "sum": + proximity_count = np.zeros( + N + ) # keeps track of how many molecules each framgent end is close to + elif method == "max": + proximity_count = np.zeros(N) else: - raise ValueError('Unknown method: {}'.format(method)) + raise ValueError("Unknown method: {}".format(method)) low = 0 high = 1 @@ -321,15 +426,15 @@ def _filterbycov(c1_in, p1_in, c2_in, p2_in, max_dist, method): # check if "high" is proximal enough to "low" # first, if chromosomes not equal, we have gone too far, and the positions are not proximal - if M[ind_sorted[low],0] != M[ind_sorted[high],0]: + if M[ind_sorted[low], 0] != M[ind_sorted[high], 0]: low += 1 - high = low + 1 # restart high + high = low + 1 # restart high continue # next, if positions are not proximal, increase low, and continue - elif np.abs(M[ind_sorted[high],1] - M[ind_sorted[low],1]) > max_dist: + elif np.abs(M[ind_sorted[high], 1] - M[ind_sorted[low], 1]) > max_dist: low += 1 - high = low + 1 # restart high + high = low + 1 # restart high continue # if on the same chromosome, and the distance is "proximal enough", add to count of both "low" and "high" positions @@ -340,28 +445,44 @@ def _filterbycov(c1_in, p1_in, c2_in, p2_in, max_dist, method): high += 1 # unsort proximity count - #proximity_count = proximity_count[ind_sorted] + # proximity_count = proximity_count[ind_sorted] proximity_count[ind_sorted] = np.copy(proximity_count) - #print(M) - #print(proximity_count) + # print(M) + # print(proximity_count) # if method is sum of pairs - if method == 'sum': - pcounts = proximity_count[0:N//2] + proximity_count[N//2:] + 1 - elif method == 'max': - pcounts = np.maximum(proximity_count[0:N//2]+1, - proximity_count[N//2:]+1) + if method == "sum": + pcounts = proximity_count[0 : N // 2] + proximity_count[N // 2 :] + 1 + elif method == "max": + pcounts = np.maximum( + proximity_count[0 : N // 2] + 1, proximity_count[N // 2 :] + 1 + ) else: - raise ValueError('Unknown method: {}'.format(method)) - + raise ValueError("Unknown method: {}".format(method)) + return pcounts -def streaming_filterbycov( method, max_dist, max_cov, sep, - c1ind, c2ind, p1ind, p2ind, s1ind, s2ind, unmapped_chrom, - instream, outstream, outstream_high, - outstream_unmapped, out_stat, mark_multi): - +def streaming_filterbycov( + method, + max_dist, + max_cov, + sep, + c1ind, + c2ind, + p1ind, + p2ind, + s1ind, + s2ind, + unmapped_chrom, + instream, + outstream, + outstream_high, + outstream_unmapped, + out_stat, + mark_multi, +): + # doing everything in memory maxind = max(c1ind, c2ind, p1ind, p2ind, s1ind, s2ind) @@ -371,7 +492,12 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, ptind = _pairsam_format.COL_PTYPE maxind = max(maxind, ptind) - c1 = []; c2 = []; p1 = []; p2 = []; s1 = []; s2 = [] + c1 = [] + c2 = [] + p1 = [] + p2 = [] + s1 = [] + s2 = [] line_buffer = [] cols_buffer = [] chromDict = {} @@ -381,7 +507,7 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, n_low = 0 instream = iter(instream) - while True: + while True: rawline = next(instream, None) stripline = rawline.strip() if rawline else None @@ -395,10 +521,10 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, if len(cols) <= maxind: raise ValueError( "Error parsing line {}: ".format(stripline) - + " expected {} columns, got {}".format(maxind, len(cols))) - - if ((cols[c1ind] == unmapped_chrom) - or (cols[c2ind] == unmapped_chrom)): + + " expected {} columns, got {}".format(maxind, len(cols)) + ) + + if (cols[c1ind] == unmapped_chrom) or (cols[c2ind] == unmapped_chrom): if outstream_unmapped: outstream_unmapped.write(stripline) @@ -407,9 +533,15 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, # add a pair to PairCounter if stats output is requested: if out_stat: - out_stat.add_pair(cols[c1ind], int(cols[p1ind]), cols[s1ind], - cols[c2ind], int(cols[p2ind]), cols[s2ind], - cols[ptind]) + out_stat.add_pair( + cols[c1ind], + int(cols[p1ind]), + cols[s1ind], + cols[c2ind], + int(cols[p2ind]), + cols[s2ind], + cols[ptind], + ) else: line_buffer.append(stripline) cols_buffer.append(cols) @@ -419,9 +551,9 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, p1.append(int(cols[p1ind])) p2.append(int(cols[p2ind])) s1.append(fetchadd(cols[s1ind], strandDict)) - s2.append(fetchadd(cols[s2ind], strandDict)) - - else: # when everything is loaded in memory... + s2.append(fetchadd(cols[s2ind], strandDict)) + + else: # when everything is loaded in memory... res = _filterbycov(c1, p1, c2, p2, max_dist, method) @@ -432,48 +564,58 @@ def streaming_filterbycov( method, max_dist, max_cov, sep, # don't forget terminal newline outstream.write("\n") if out_stat: - out_stat.add_pair(cols_buffer[i][c1ind], - int(cols_buffer[i][p1ind]), - cols_buffer[i][s1ind], - cols_buffer[i][c2ind], - int(cols_buffer[i][p2ind]), - cols_buffer[i][s2ind], - cols_buffer[i][ptind]) + out_stat.add_pair( + cols_buffer[i][c1ind], + int(cols_buffer[i][p1ind]), + cols_buffer[i][s1ind], + cols_buffer[i][c2ind], + int(cols_buffer[i][p2ind]), + cols_buffer[i][s2ind], + cols_buffer[i][ptind], + ) # high-frequency interactor pairs: else: if out_stat: - out_stat.add_pair(cols_buffer[i][c1ind], - int(cols_buffer[i][p1ind]), - cols_buffer[i][s1ind], - cols_buffer[i][c2ind], - int(cols_buffer[i][p2ind]), - cols_buffer[i][s2ind], - 'FF' ) + out_stat.add_pair( + cols_buffer[i][c1ind], + int(cols_buffer[i][p1ind]), + cols_buffer[i][s1ind], + cols_buffer[i][c2ind], + int(cols_buffer[i][p2ind]), + cols_buffer[i][s2ind], + "FF", + ) if outstream_high: outstream_high.write( - # FF-marked pair: - sep.join(mark_split_pair_as_dup(cols_buffer[i])) - if mark_multi - # pair as is: - else line_buffer[i] ) + # FF-marked pair: + sep.join(mark_split_pair_as_dup(cols_buffer[i])) + if mark_multi + # pair as is: + else line_buffer[i] + ) # don't forget terminal newline - outstream_high.write('\n') - + outstream_high.write("\n") + # flush buffers and perform necessary checks here: - c1 = []; c2 = []; p1 = []; p2 = []; s1 = []; s2 = [] - line_buffer = line_buffer[len(res):] - cols_buffer = cols_buffer[len(res):] + c1 = [] + c2 = [] + p1 = [] + p2 = [] + s1 = [] + s2 = [] + line_buffer = line_buffer[len(res) :] + cols_buffer = cols_buffer[len(res) :] if not stripline: - if(len(line_buffer) != 0): + if len(line_buffer) != 0: raise ValueError( "{} lines left in the buffer, ".format(len(line_buffer)) + "should be none;" - + "something went terribly wrong") + + "something went terribly wrong" + ) break - + break - - -if __name__ == '__main__': + +if __name__ == "__main__": filterbycov() diff --git a/pairtools/pairtools_flip.py b/pairtools/pairtools_flip.py index 552500cf..95bb1a83 100644 --- a/pairtools/pairtools_flip.py +++ b/pairtools/pairtools_flip.py @@ -4,41 +4,35 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options import warnings -UTIL_NAME = 'pairtools_flip' +UTIL_NAME = "pairtools_flip" -@cli.command() - -@click.argument( - 'pairs_path', - type=str, - required=False) +@cli.command() +@click.argument("pairs_path", type=str, required=False) @click.option( - "-c", "--chroms-path", + "-c", + "--chroms-path", type=str, required=True, - help='Chromosome order used to flip interchromosomal mates: ' - 'path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose ' - 'first column lists scaffold names. Any scaffolds not listed will be ' - 'ordered lexicographically following the names provided.') - + help="Chromosome order used to flip interchromosomal mates: " + "path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose " + "first column lists scaffold names. Any scaffolds not listed will be " + "ordered lexicographically following the names provided.", +) @click.option( - '-o', "--output", - type=str, - default="", - help='output file.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) @common_io_options +def flip(pairs_path, chroms_path, output, **kwargs): + """Flip pairs to get an upper-triangular matrix. -def flip( - pairs_path, chroms_path, output, - **kwargs - ): - '''Flip pairs to get an upper-triangular matrix. - - Change the order of side1 and side2 in pairs, such that + Change the order of side1 and side2 in pairs, such that (order(chrom1) < order(chrom2) or (order(chrom1) == order(chrom2)) and (pos1 <=pos2)) Equivalent to reflecting the lower triangle of a Hi-C matrix onto @@ -48,50 +42,62 @@ def flip( PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - ''' - flip_py( - pairs_path, chroms_path, output, - **kwargs + """ + flip_py(pairs_path, chroms_path, output, **kwargs) + + +def flip_py(pairs_path, chroms_path, output, **kwargs): + + instream = ( + _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout ) - -def flip_py( - pairs_path, chroms_path, output, - **kwargs - ): - - instream = (_fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - if pairs_path else sys.stdin) - outstream = (_fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) - if output else sys.stdout) chromosomes = _headerops.get_chrom_order(chroms_path) - chrom_enum = dict(zip([_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), - range(len(chromosomes)+1))) + chrom_enum = dict( + zip( + [_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), + range(len(chromosomes) + 1), + ) + ) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - outstream.writelines((l+'\n' for l in header)) + outstream.writelines((l + "\n" for l in header)) column_names = _headerops.extract_column_names(header) if len(column_names) == 0: column_names = _pairsam_format.COLUMNS - chrom1_col = column_names.index('chrom1') - chrom2_col = column_names.index('chrom2') - pos1_col = column_names.index('pos1') - pos2_col = column_names.index('pos2') - pair_type_col = (column_names.index('pair_type') - if 'pair_type' in column_names - else -1) + chrom1_col = column_names.index("chrom1") + chrom2_col = column_names.index("chrom2") + pos1_col = column_names.index("pos1") + pos2_col = column_names.index("pos2") + pair_type_col = ( + column_names.index("pair_type") if "pair_type" in column_names else -1 + ) col_pairs_to_flip = [ - (column_names.index(col), column_names.index(col[:-1]+'2')) + (column_names.index(col), column_names.index(col[:-1] + "2")) for col in column_names - if col.endswith('1') and (col[:-1]+'2') in column_names] + if col.endswith("1") and (col[:-1] + "2") in column_names + ] for line in body_stream: cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) @@ -106,12 +112,12 @@ def flip_py( elif is_annotated2 and not is_annotated1: has_correct_order = False elif not is_annotated1 and not is_annotated2: - has_correct_order = cols[chrom1_col] _pairsam_format.COL_SAM1) and (len(cols) > _pairsam_format.COL_SAM2): - for i in (_pairsam_format.COL_SAM1, - _pairsam_format.COL_SAM2): - + original_has_newline = cols[-1].endswith("\n") + + cols[_pairsam_format.COL_PTYPE] = "DD" + + if (len(cols) > _pairsam_format.COL_SAM1) and ( + len(cols) > _pairsam_format.COL_SAM2 + ): + for i in (_pairsam_format.COL_SAM1, _pairsam_format.COL_SAM2): + # split each sam column into sam entries, tag and assemble back cols[i] = _pairsam_format.INTER_SAM_SEP.join( - [mark_sam_as_dup(sam) - for sam in cols[i].split(_pairsam_format.INTER_SAM_SEP) - ]) - - if original_has_newline and not cols[-1].endswith('\n'): - cols[-1] = cols[-1]+'\n' + [ + mark_sam_as_dup(sam) + for sam in cols[i].split(_pairsam_format.INTER_SAM_SEP) + ] + ) + + if original_has_newline and not cols[-1].endswith("\n"): + cols[-1] = cols[-1] + "\n" return cols + def mark_sam_as_dup(sam): - '''Tag the binary flag and the optional pair type field of a sam entry - as a PCR duplicate.''' + """Tag the binary flag and the optional pair type field of a sam entry + as a PCR duplicate.""" samcols = sam.split(_pairsam_format.SAM_SEP) if len(samcols) == 1: @@ -90,10 +100,10 @@ def mark_sam_as_dup(sam): samcols[1] = str(int(samcols[1]) | 1024) for j in range(11, len(samcols)): - if samcols[j].startswith('Yt:Z:'): - samcols[j] = 'Yt:Z:DD' + if samcols[j].startswith("Yt:Z:"): + samcols[j] = "Yt:Z:DD" return _pairsam_format.SAM_SEP.join(samcols) -if __name__ == '__main__': +if __name__ == "__main__": markasdup() diff --git a/pairtools/pairtools_merge.py b/pairtools/pairtools_merge.py index 340fcf0f..588ebbc2 100644 --- a/pairtools/pairtools_merge.py +++ b/pairtools/pairtools_merge.py @@ -7,121 +7,120 @@ from . import _fileio, _pairsam_format, _headerops, cli -UTIL_NAME = 'pairtools_merge' +UTIL_NAME = "pairtools_merge" @cli.command() @click.argument( - 'pairs_path', - nargs=-1, + "pairs_path", + nargs=-1, type=str, - ) +) @click.option( - "-o", "--output", - type=str, - default="", - help='output file.' - ' If the path ends with .gz/.lz4, the output is compressed by bgzip/lz4c.' - ' By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz/.lz4, the output is compressed by bgzip/lz4c." + " By default, the output is printed into stdout.", +) @click.option( - "--max-nmerge", - type=int, - default=8, + "--max-nmerge", + type=int, + default=8, show_default=True, - help='The maximal number of inputs merged at once. For more, store ' - 'merged intermediates in temporary files.' - ) - + help="The maximal number of inputs merged at once. For more, store " + "merged intermediates in temporary files.", +) @click.option( - "--tmpdir", - type=str, - default='', - help='Custom temporary folder for merged intermediates.' - ) - + "--tmpdir", + type=str, + default="", + help="Custom temporary folder for merged intermediates.", +) @click.option( - "--memory", - type=str, - default='2G', + "--memory", + type=str, + default="2G", show_default=True, - help='The amount of memory used by default.', - ) - + help="The amount of memory used by default.", +) @click.option( "--compress-program", type=str, - default='', + default="", show_default=True, - help='A binary to compress temporary merged chunks. ' - 'Must decompress input when the flag -d is provided. ' - 'Suggested alternatives: lz4c, gzip, lzop, snzip. ' - 'NOTE: fails silently if the command syntax is wrong. ' - ) - + help="A binary to compress temporary merged chunks. " + "Must decompress input when the flag -d is provided. " + "Suggested alternatives: lz4c, gzip, lzop, snzip. " + "NOTE: fails silently if the command syntax is wrong. ", +) @click.option( - "--nproc", - type=int, - default=8, - help='Number of threads for merging.', + "--nproc", + type=int, + default=8, + help="Number of threads for merging.", show_default=True, - ) - +) @click.option( - '--nproc-in', - type=int, - default=1, + "--nproc-in", + type=int, + default=1, show_default=True, - help='Number of processes used by the auto-guessed input decompressing command.' - ) + help="Number of processes used by the auto-guessed input decompressing command.", +) @click.option( - '--nproc-out', - type=int, - default=8, + "--nproc-out", + type=int, + default=8, show_default=True, - help='Number of processes used by the auto-guessed output compressing command.' - ) + help="Number of processes used by the auto-guessed output compressing command.", +) @click.option( - '--cmd-in', - type=str, - default=None, - help='A command to decompress the input. ' - 'If provided, fully overrides the auto-guessed command. ' - 'Does not work with stdin. ' - 'Must read input from stdin and print output into stdout. ' - 'EXAMPLE: pbgzip -dc -n 3' - ) + "--cmd-in", + type=str, + default=None, + help="A command to decompress the input. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdin. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -dc -n 3", +) @click.option( - '--cmd-out', - type=str, - default=None, - help='A command to compress the output. ' - 'If provided, fully overrides the auto-guessed command. ' - 'Does not work with stdout. ' - 'Must read input from stdin and print output into stdout. ' - 'EXAMPLE: pbgzip -c -n 8' - ) + "--cmd-out", + type=str, + default=None, + help="A command to compress the output. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdout. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -c -n 8", +) @click.option( "--keep-first-header/--no-keep-first-header", default=False, show_default=True, - help='Keep the first header or merge the headers together. Default: merge headers.', - ) + help="Keep the first header or merge the headers together. Default: merge headers.", +) @click.option( "--concatenate/--no-concatenate", default=False, show_default=True, - help='Simple concatenate instead of merging sorted files.', - ) + help="Simple concatenate instead of merging sorted files.", +) # Using custom IO options -def merge(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs): + +def merge( + pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs +): """Merge .pairs/.pairsam files. By default, assumes that the files are sorted and maintains the sorting. - Merge triu-flipped sorted pairs/pairsam files. If present, the @SQ records - of the SAM header must be identical; the sorting order of - these lines is taken from the first file in the list. + Merge triu-flipped sorted pairs/pairsam files. If present, the @SQ records + of the SAM header must be identical; the sorting order of + these lines is taken from the first file in the list. The ID fields of the @PG records of the SAM header are modified with a numeric suffix to produce unique records. The other unique SAM and non-SAM header lines are copied into the output header. @@ -129,26 +128,43 @@ def merge(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, npro PAIRS_PATH : upper-triangular flipped sorted .pairs/.pairsam files to merge or a group/groups of .pairs/.pairsam files specified by a wildcard. For paths ending in .gz/.lz4, the files are decompressed by bgzip/lz4c. - + """ - merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs) + merge_py( + pairs_path, + output, + max_nmerge, + tmpdir, + memory, + compress_program, + nproc, + **kwargs, + ) -def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs): +def merge_py( + pairs_path, output, max_nmerge, tmpdir, memory, compress_program, nproc, **kwargs +): paths = sum([glob.glob(mask) for mask in pairs_path], []) - if len(paths)==0: + if len(paths) == 0: raise ValueError(f"No input paths: {pairs_path}") - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) # if there is only one input, bypass merging and do not modify the header if len(paths) == 1: - instream = _fileio.auto_open(paths[0], mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) + instream = _fileio.auto_open( + paths[0], + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) for line in instream: outstream.write(line) if outstream != sys.stdout: @@ -158,33 +174,35 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n headers = [] for path in paths: - f = _fileio.auto_open(path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) + f = _fileio.auto_open( + path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) h, _ = _headerops.get_header(f) headers.append(h) f.close() # Skip other headers if keep_first_header is True (False by default): - if kwargs.get('keep_first_header', False): + if kwargs.get("keep_first_header", False): break if not _headerops.all_same_columns(headers): raise ValueError("Input pairs cannot contain different columns") merged_header = _headerops.merge_headers(headers) - merged_header = _headerops.append_new_pg( - merged_header, ID=UTIL_NAME, PN=UTIL_NAME) + merged_header = _headerops.append_new_pg(merged_header, ID=UTIL_NAME, PN=UTIL_NAME) - outstream.writelines((l+'\n' for l in merged_header)) + outstream.writelines((l + "\n" for l in merged_header)) outstream.flush() # If concatenation requested instead of merging sorted input: - if kwargs.get('concatenate', False): - command = r''' - /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat ''' + if kwargs.get("concatenate", False): + command = r""" + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat """ # Full merge that keeps the ordered input: else: - command = r''' + command = r""" /bin/bash -c 'export LC_COLLATE=C; export LANG=C; sort -k {0},{0} -k {1},{1} -k {2},{2}n -k {3},{3}n -k {4},{4} --merge @@ -194,29 +212,42 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n {8} -S {9} {10} - '''.replace('\n',' ').format( - _pairsam_format.COL_C1+1, - _pairsam_format.COL_C2+1, - _pairsam_format.COL_P1+1, - _pairsam_format.COL_P2+1, - _pairsam_format.COL_PTYPE+1, - _pairsam_format.PAIRSAM_SEP_ESCAPE, - ' --parallel={} '.format(nproc) if nproc > 1 else ' ', - ' --batch-size={} '.format(max_nmerge) if max_nmerge else ' ', - ' --temporary-directory={} '.format(tmpdir) if tmpdir else ' ', - memory, - (' --compress-program={} '.format(compress_program) - if compress_program else ' '), - ) + """.replace( + "\n", " " + ).format( + _pairsam_format.COL_C1 + 1, + _pairsam_format.COL_C2 + 1, + _pairsam_format.COL_P1 + 1, + _pairsam_format.COL_P2 + 1, + _pairsam_format.COL_PTYPE + 1, + _pairsam_format.PAIRSAM_SEP_ESCAPE, + " --parallel={} ".format(nproc) if nproc > 1 else " ", + " --batch-size={} ".format(max_nmerge) if max_nmerge else " ", + " --temporary-directory={} ".format(tmpdir) if tmpdir else " ", + memory, + ( + " --compress-program={} ".format(compress_program) + if compress_program + else " " + ), + ) for path in paths: - if kwargs.get('cmd_in', None): - command += r''' <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')'''.format(path, kwargs['cmd_in']) - elif path.endswith('.gz'): - command += r''' <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')'''.format(kwargs['nproc_in'], path) - elif path.endswith('.lz4'): - command += r''' <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')'''.format(path) + if kwargs.get("cmd_in", None): + command += r""" <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + path, kwargs["cmd_in"] + ) + elif path.endswith(".gz"): + command += ( + r""" <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + kwargs["nproc_in"], path + ) + ) + elif path.endswith(".lz4"): + command += r""" <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + path + ) else: - command += r''' <(sed -n -e '\''/^[^#]/,$p'\'' {})'''.format(path) + command += r""" <(sed -n -e '\''/^[^#]/,$p'\'' {})""".format(path) command += "'" subprocess.check_call(command, shell=True, stdout=outstream) @@ -225,5 +256,5 @@ def merge_py(pairs_path, output, max_nmerge, tmpdir, memory, compress_program, n outstream.close() -if __name__ == '__main__': +if __name__ == "__main__": merge() diff --git a/pairtools/pairtools_parse.py b/pairtools/pairtools_parse.py index 41cbf21b..b174f2e7 100644 --- a/pairtools/pairtools_parse.py +++ b/pairtools/pairtools_parse.py @@ -172,12 +172,7 @@ ) @common_io_options def parse( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ): """Find ligation pairs in .sam data, make .pairs. SAM_PATH : an input .sam/.bam file with paired-end sequence alignments of @@ -185,44 +180,45 @@ def parse( bam with samtools. By default, the input is read from stdin. """ parse_py( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ) def parse_py( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ): ### Set up input stream if sam_path: # open input sam file with pysam - input_sam = AlignmentFilePairtoolized(sam_path, "r", threads=kwargs.get('nproc_in')) + input_sam = AlignmentFilePairtoolized( + sam_path, "r", threads=kwargs.get("nproc_in") + ) else: # read from stdin - input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get('nproc_in')) + input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get("nproc_in")) ### Set up output streams - outstream = _fileio.auto_open(output, mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None)) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) out_alignments_stream, out_stats_stream = None, None if output_parsed_alignments: - out_alignments_stream = _fileio.auto_open(output_parsed_alignments, mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None)) + out_alignments_stream = _fileio.auto_open( + output_parsed_alignments, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) if output_stats: - out_stats_stream = _fileio.auto_open(output_stats, mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None)) + out_stats_stream = _fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) if out_alignments_stream: out_alignments_stream.write( @@ -276,12 +272,7 @@ def parse_py( ### Parse input and write to the outputs streaming_classify( - input_sam, - outstream, - chromosomes, - out_alignments_stream, - out_stat, - **kwargs + input_sam, outstream, chromosomes, out_alignments_stream, out_stat, **kwargs ) # save statistics to a file if it was requested: diff --git a/pairtools/pairtools_parse2.py b/pairtools/pairtools_parse2.py index 03fba264..4df05deb 100644 --- a/pairtools/pairtools_parse2.py +++ b/pairtools/pairtools_parse2.py @@ -43,9 +43,9 @@ type=str, required=True, help="Chromosome order used to flip interchromosomal mates: " - "path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose " - "first column lists scaffold names. Any scaffolds not listed will be " - "ordered lexicographically following the names provided.", + "path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose " + "first column lists scaffold names. Any scaffolds not listed will be " + "ordered lexicographically following the names provided.", ) @click.option( "-o", @@ -53,35 +53,35 @@ type=str, default="", help="output file. " - " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." - "By default, the output is printed into stdout. ", + " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." + "By default, the output is printed into stdout. ", ) @click.option( "--report-position", type=click.Choice(["junction", "read", "walk", "outer"]), default="outer", help="Specifies what end will be reported as pos5 of the rescued pairs. " - "junction - inner ends of sequential alignments, " - "read - 5'-end of alignments relative to the forward and reverse read, " - "walk - 5'-end of alignments relative to the whole walk, " - "outer - outer ends. " + "junction - inner ends of sequential alignments, " + "read - 5'-end of alignments relative to the forward and reverse read, " + "walk - 5'-end of alignments relative to the whole walk, " + "outer - outer ends. ", ) @click.option( "--report-orientation", type=click.Choice(["pair", "read", "walk", "junction"]), default="pair", help="Specifies what orientation will be reported for the rescued pairs. " - "pair - Hi-C-like orientation as if each pair was sequenced independently, " - "read - orientation of each left/right read, " - "walk - orientation of the walk, " - "junction - orientation opposite to 'pair', orientation is reported as if pair was sequenced starting from the junction" + "pair - Hi-C-like orientation as if each pair was sequenced independently, " + "read - orientation of each left/right read, " + "walk - orientation of the walk, " + "junction - orientation opposite to 'pair', orientation is reported as if pair was sequenced starting from the junction", ) @click.option( "--report-alignment-end", type=click.Choice(["5", "3"]), default="5", help="Specifies whether the 5' or 3' end of the alignment is reported as" - " the position of the Hi-C read.", + " the position of the Hi-C read.", ) @click.option( "--assembly", @@ -101,9 +101,9 @@ default=20, show_default=True, help="read segments that are not covered by any alignment and" - ' longer than the specified value are treated as "null" alignments.' - " These null alignments convert otherwise linear alignments into walks," - " and affect how they get reported as a Hi-C pair.", + ' longer than the specified value are treated as "null" alignments.' + " These null alignments convert otherwise linear alignments into walks," + " and affect how they get reported as a Hi-C pair.", ) @click.option( "--max-fragment-size", @@ -128,7 +128,7 @@ "--no-flip", is_flag=True, help="If specified, do not flip pairs in genomic order and instead preserve " - "the order in which they were sequenced.", + "the order in which they were sequenced.", ) @click.option( "--drop-readid", @@ -140,10 +140,10 @@ type=str, default=None, help="A Python expression to modify read IDs. Useful when read IDs differ " - "between the two reads of a pair. Must be a valid Python expression that " - "uses variables called readID and/or i (the 0-based index of the read pair " - "in the bam file) and returns a new value, e.g. \"readID[:-2]+'_'+str(i)\". " - "Make sure that transformed readIDs remain unique!", + "between the two reads of a pair. Must be a valid Python expression that " + "uses variables called readID and/or i (the 0-based index of the read pair " + "in the bam file) and returns a new value, e.g. \"readID[:-2]+'_'+str(i)\". " + "Make sure that transformed readIDs remain unique!", show_default=True, ) @click.option( @@ -164,8 +164,8 @@ type=click.STRING, default="", help="Report extra columns describing alignments " - "Possible values (can take multiple values as a comma-separated " - "list): a SAM tag (any pair of uppercase letters) or {}.".format( + "Possible values (can take multiple values as a comma-separated " + "list): a SAM tag (any pair of uppercase letters) or {}.".format( ", ".join(EXTRA_COLUMNS) ), ) @@ -174,26 +174,21 @@ type=str, default="", help="output file for all parsed alignments, including walks." - " Useful for debugging and rnalysis of walks." - " If file exists, it will be open in the append mode." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." - " By default, not used.", + " Useful for debugging and rnalysis of walks." + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4-compressed." + " By default, not used.", ) @click.option( "--output-stats", type=str, default="", help="output file for various statistics of pairs file. " - " By default, statistics is not generated.", + " By default, statistics is not generated.", ) @common_io_options def parse2( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ): """Find pairs in .sam data, make .pairs. SAM_PATH : an input .sam/.bam file with paired-end sequence alignments of @@ -201,28 +196,20 @@ def parse2( bam with samtools. By default, the input is read from stdin. """ parse2_py( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ) def parse2_py( - sam_path, - chroms_path, - output, - output_parsed_alignments, - output_stats, - **kwargs + sam_path, chroms_path, output, output_parsed_alignments, output_stats, **kwargs ): ### Set up input stream if sam_path: # open input sam file with pysam - input_sam = AlignmentFilePairtoolized(sam_path, "r", threads=kwargs.get('nproc_in')) + input_sam = AlignmentFilePairtoolized( + sam_path, "r", threads=kwargs.get("nproc_in") + ) else: # read from stdin - input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get('nproc_in')) + input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get("nproc_in")) ### Set up output streams outstream = ( diff --git a/pairtools/pairtools_phase.py b/pairtools/pairtools_phase.py index 122d3fee..727d65d8 100644 --- a/pairtools/pairtools_phase.py +++ b/pairtools/pairtools_phase.py @@ -4,198 +4,185 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options -UTIL_NAME = 'pairtools_phase' +UTIL_NAME = "pairtools_phase" -@cli.command() -@click.argument( - 'pairs_path', - type=str, - required=False) +@cli.command() +@click.argument("pairs_path", type=str, required=False) @click.option( - '-o', "--output", - type=str, - default="", - help='output file.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) @click.option( - "--phase-suffixes", + "--phase-suffixes", nargs=2, - #type=click.Tuple([str, str]), - help='phase suffixes.' - ) - + # type=click.Tuple([str, str]), + help="phase suffixes.", +) @click.option( - "--clean-output", + "--clean-output", is_flag=True, - help='drop all columns besides the standard ones and phase1/2' - ) - + help="drop all columns besides the standard ones and phase1/2", +) @common_io_options - -def phase( - pairs_path, - output, - phase_suffixes, - clean_output, - **kwargs - ): - '''Phase pairs mapped to a diploid genome. +def phase(pairs_path, output, phase_suffixes, clean_output, **kwargs): + """Phase pairs mapped to a diploid genome. PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - ''' - phase_py( - pairs_path, output, phase_suffixes, clean_output, - **kwargs - ) + """ + phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs) - -def phase_py( - pairs_path, output, phase_suffixes, clean_output, - **kwargs - ): - instream = _fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) +def phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs): + + instream = _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) old_column_names = _headerops.extract_column_names(header) if clean_output: - new_column_names = [col for col in old_column_names - if col in _pairsam_format.COLUMNS] - new_column_idxs = [i for i,col in enumerate(old_column_names) - if col in _pairsam_format.COLUMNS] + [ - len(old_column_names), len(old_column_names)+1] + new_column_names = [ + col for col in old_column_names if col in _pairsam_format.COLUMNS + ] + new_column_idxs = [ + i + for i, col in enumerate(old_column_names) + if col in _pairsam_format.COLUMNS + ] + [len(old_column_names), len(old_column_names) + 1] else: new_column_names = list(old_column_names) - new_column_names.append('phase1') - new_column_names.append('phase2') + new_column_names.append("phase1") + new_column_names.append("phase2") header = _headerops._update_header_entry( - header, 'columns', ' '.join(new_column_names)) - - if ( ('XB1' not in old_column_names) - or ('XB2' not in old_column_names) - or ('AS1' not in old_column_names) - or ('AS2' not in old_column_names) - or ('XS1' not in old_column_names) - or ('XS2' not in old_column_names) - ): - raise ValueError( - 'The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0') + header, "columns", " ".join(new_column_names) + ) - COL_XB1 = old_column_names.index('XB1') - COL_XB2 = old_column_names.index('XB2') - COL_AS1 = old_column_names.index('AS1') - COL_AS2 = old_column_names.index('AS2') - COL_XS1 = old_column_names.index('XS1') - COL_XS2 = old_column_names.index('XS2') + if ( + ("XB1" not in old_column_names) + or ("XB2" not in old_column_names) + or ("AS1" not in old_column_names) + or ("AS2" not in old_column_names) + or ("XS1" not in old_column_names) + or ("XS2" not in old_column_names) + ): + raise ValueError( + "The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0" + ) - outstream.writelines((l+'\n' for l in header)) + COL_XB1 = old_column_names.index("XB1") + COL_XB2 = old_column_names.index("XB2") + COL_AS1 = old_column_names.index("AS1") + COL_AS2 = old_column_names.index("AS2") + COL_XS1 = old_column_names.index("XS1") + COL_XS2 = old_column_names.index("XS2") + outstream.writelines((l + "\n" for l in header)) def get_chrom_phase(chrom, phase_suffixes): if chrom.endswith(phase_suffixes[0]): - return '0', chrom[:-len(phase_suffixes[0])] + return "0", chrom[: -len(phase_suffixes[0])] elif chrom.endswith(phase_suffixes[1]): - return '1', chrom[:-len(phase_suffixes[1])] + return "1", chrom[: -len(phase_suffixes[1])] else: - return '!', chrom - + return "!", chrom def phase_side(chrom, XB, AS, XS, phase_suffixes): phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) - XBs = [i for i in XB.split(';') if len(i)>0] + XBs = [i for i in XB.split(";") if len(i) > 0] if AS > XS: return phase, chrom_base elif len(XBs) >= 1: if len(XBs) >= 2: - alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS = XBs[1].split(',') + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS = XBs[1].split(",") if alt2_AS == XS == AS: - return '!', '!' + return "!", "!" - alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS = XBs[0].split(',') + alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS = XBs[0].split(",") alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) - alt_is_homologue = ( - (chrom_base == alt_chrom_base) - and - ( - ((phase=='0') and (alt_phase=='1')) - or - ((phase=='1') and (alt_phase=='0')) - ) + alt_is_homologue = (chrom_base == alt_chrom_base) and ( + ((phase == "0") and (alt_phase == "1")) + or ((phase == "1") and (alt_phase == "0")) ) - - if alt_is_homologue: - return '.', chrom_base - return '!', '!' + if alt_is_homologue: + return ".", chrom_base + return "!", "!" for line in body_stream: cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) - cols.append('!') - cols.append('!') + cols.append("!") + cols.append("!") pair_type = cols[_pairsam_format.COL_PTYPE] if cols[_pairsam_format.COL_C1] != _pairsam_format.UNMAPPED_CHROM: phase1, chrom_base1 = phase_side( cols[_pairsam_format.COL_C1], - cols[COL_XB1], + cols[COL_XB1], int(cols[COL_AS1]), int(cols[COL_XS1]), - phase_suffixes - ) + phase_suffixes, + ) cols[-2] = phase1 cols[_pairsam_format.COL_C1] = chrom_base1 - if chrom_base1 == '!': + if chrom_base1 == "!": cols[_pairsam_format.COL_C1] = _pairsam_format.UNMAPPED_CHROM cols[_pairsam_format.COL_P1] = str(_pairsam_format.UNMAPPED_POS) cols[_pairsam_format.COL_S1] = _pairsam_format.UNMAPPED_STRAND - pair_type = 'M' + pair_type[1] + pair_type = "M" + pair_type[1] if cols[_pairsam_format.COL_C2] != _pairsam_format.UNMAPPED_CHROM: phase2, chrom_base2 = phase_side( cols[_pairsam_format.COL_C2], - cols[COL_XB2], + cols[COL_XB2], int(cols[COL_AS2]), int(cols[COL_XS2]), - phase_suffixes - ) + phase_suffixes, + ) cols[-1] = phase2 cols[_pairsam_format.COL_C2] = chrom_base2 - if chrom_base2 == '!': + if chrom_base2 == "!": cols[_pairsam_format.COL_C2] = _pairsam_format.UNMAPPED_CHROM cols[_pairsam_format.COL_P2] = str(_pairsam_format.UNMAPPED_POS) cols[_pairsam_format.COL_S2] = _pairsam_format.UNMAPPED_STRAND - pair_type = pair_type[0] + 'M' + pair_type = pair_type[0] + "M" cols[_pairsam_format.COL_PTYPE] = pair_type if clean_output: cols = [cols[i] for i in new_column_idxs] - + outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) - outstream.write('\n') + outstream.write("\n") if instream != sys.stdin: instream.close() @@ -203,5 +190,6 @@ def phase_side(chrom, XB, AS, XS, phase_suffixes): if outstream != sys.stdout: outstream.close() -if __name__ == '__main__': + +if __name__ == "__main__": phase() diff --git a/pairtools/pairtools_restrict.py b/pairtools/pairtools_restrict.py index ad6192d0..8d1b8303 100644 --- a/pairtools/pairtools_restrict.py +++ b/pairtools/pairtools_restrict.py @@ -10,34 +10,31 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options -UTIL_NAME = 'pairtools_restrict' +UTIL_NAME = "pairtools_restrict" -@cli.command() - -@click.argument( - 'pairs_path', - type=str, - required=False) +@cli.command() +@click.argument("pairs_path", type=str, required=False) @click.option( - '-f', '--frags', + "-f", + "--frags", type=str, required=True, - help='a tab-separated BED file with the positions of restriction fragments ' - '(chrom, start, end). Can be generated using cooler digest.') - + help="a tab-separated BED file with the positions of restriction fragments " + "(chrom, start, end). Can be generated using cooler digest.", +) @click.option( - '-o', "--output", + "-o", + "--output", type=str, default="", - help='output .pairs/.pairsam file.' - ' If the path ends with .gz/.lz4, the output is compressed by bgzip/lz4c.' - ' By default, the output is printed into stdout.') - + help="output .pairs/.pairsam file." + " If the path ends with .gz/.lz4, the output is compressed by bgzip/lz4c." + " By default, the output is printed into stdout.", +) @common_io_options - def restrict(pairs_path, frags, output, **kwargs): - '''Assign restriction fragments to pairs. + """Assign restriction fragments to pairs. Identify the restriction fragments that got ligated into a Hi-C molecule. @@ -45,41 +42,57 @@ def restrict(pairs_path, frags, output, **kwargs): PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - ''' + """ restrict_py(pairs_path, frags, output, **kwargs) -def restrict_py(pairs_path, frags, output, **kwargs): - instream = _fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) +def restrict_py(pairs_path, frags, output, **kwargs): + instream = _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - header = _headerops.append_columns(header, - ['rfrag1', 'rfrag_start1', 'rfrag_end1', - 'rfrag2', 'rfrag_start2', 'rfrag_end2']) - - outstream.writelines((l+'\n' for l in header)) + header = _headerops.append_columns( + header, + [ + "rfrag1", + "rfrag_start1", + "rfrag_end1", + "rfrag2", + "rfrag_start2", + "rfrag_end2", + ], + ) + + outstream.writelines((l + "\n" for l in header)) rfrags = np.genfromtxt( frags, - delimiter='\t', - comments='#', + delimiter="\t", + comments="#", dtype=None, - encoding='ascii', - names=['chrom', 'start', 'end']) - - - rfrags.sort(order=['chrom', 'start', 'end']) - chrom_borders = np.r_[0, - 1+np.where(rfrags['chrom'][:-1] != rfrags['chrom'][1:])[0], - rfrags.shape[0]] - rfrags = { rfrags['chrom'][i] : np.concatenate([[0], rfrags['end'][i:j] + 1]) - for i, j in zip(chrom_borders[:-1], chrom_borders[1:])} + encoding="ascii", + names=["chrom", "start", "end"], + ) + + rfrags.sort(order=["chrom", "start", "end"]) + chrom_borders = np.r_[ + 0, 1 + np.where(rfrags["chrom"][:-1] != rfrags["chrom"][1:])[0], rfrags.shape[0] + ] + rfrags = { + rfrags["chrom"][i]: np.concatenate([[0], rfrags["end"][i:j] + 1]) + for i, j in zip(chrom_borders[:-1], chrom_borders[1:]) + } for line in body_stream: cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) @@ -90,7 +103,7 @@ def restrict_py(pairs_path, frags, output, **kwargs): cols += [str(rfrag_idx1), str(rfrag_start1), str(rfrag_end1)] cols += [str(rfrag_idx2), str(rfrag_start2), str(rfrag_end2)] outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) - outstream.write('\n') + outstream.write("\n") if instream != sys.stdin: instream.close() @@ -101,17 +114,30 @@ def restrict_py(pairs_path, frags, output, **kwargs): def find_rfrag(rfrags, chrom, pos): # Return empty if chromosome is unmapped: - if chrom==_pairsam_format.UNMAPPED_CHROM: - return _pairsam_format.UNANNOTATED_RFRAG, _pairsam_format.UNMAPPED_POS, _pairsam_format.UNMAPPED_POS + if chrom == _pairsam_format.UNMAPPED_CHROM: + return ( + _pairsam_format.UNANNOTATED_RFRAG, + _pairsam_format.UNMAPPED_POS, + _pairsam_format.UNMAPPED_POS, + ) try: rsites_chrom = rfrags[chrom] except ValueError as e: - warnings.warn(f"Chomosome {chrom} does not have annotated restriction fragments, return empty.") - return _pairsam_format.UNANNOTATED_RFRAG, _pairsam_format.UNMAPPED_POS, _pairsam_format.UNMAPPED_POS - - idx = min( max(0, rsites_chrom.searchsorted(pos, 'right')-1), len(rsites_chrom)-2) - return idx, rsites_chrom[idx], rsites_chrom[idx+1] - -if __name__ == '__main__': + warnings.warn( + f"Chomosome {chrom} does not have annotated restriction fragments, return empty." + ) + return ( + _pairsam_format.UNANNOTATED_RFRAG, + _pairsam_format.UNMAPPED_POS, + _pairsam_format.UNMAPPED_POS, + ) + + idx = min( + max(0, rsites_chrom.searchsorted(pos, "right") - 1), len(rsites_chrom) - 2 + ) + return idx, rsites_chrom[idx], rsites_chrom[idx + 1] + + +if __name__ == "__main__": restrict() diff --git a/pairtools/pairtools_sample.py b/pairtools/pairtools_sample.py index 1a0a650f..03310188 100644 --- a/pairtools/pairtools_sample.py +++ b/pairtools/pairtools_sample.py @@ -5,68 +5,59 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options -UTIL_NAME = 'pairtools_sample' +UTIL_NAME = "pairtools_sample" -@cli.command() - -@click.argument( - 'fraction', - type=float, - required=True) - -@click.argument( - 'pairs_path', - type=str, - required=False) +@cli.command() +@click.argument("fraction", type=float, required=True) +@click.argument("pairs_path", type=str, required=False) @click.option( - '-o', "--output", - type=str, - default="", - help='output file.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) @click.option( - '-s', "--seed", - type=int, - default=None, - help='the seed of the random number generator.') - + "-s", + "--seed", + type=int, + default=None, + help="the seed of the random number generator.", +) @common_io_options +def sample(fraction, pairs_path, output, seed, **kwargs): + """Select a random subset of pairs in a pairs file. -def sample( - fraction, pairs_path, output, seed, - **kwargs - ): - '''Select a random subset of pairs in a pairs file. - - FRACTION: the fraction of the randomly selected pairs subset + FRACTION: the fraction of the randomly selected pairs subset PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - ''' - sample_py( - fraction, pairs_path, output, seed, - **kwargs + """ + sample_py(fraction, pairs_path, output, seed, **kwargs) + + +def sample_py(fraction, pairs_path, output, seed, **kwargs): + + instream = _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), ) - -def sample_py( - fraction, pairs_path, output, seed, - **kwargs - ): - - instream = _fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - outstream.writelines((l+'\n' for l in header)) + outstream.writelines((l + "\n" for l in header)) random.seed(seed) @@ -81,5 +72,5 @@ def sample_py( outstream.close() -if __name__ == '__main__': +if __name__ == "__main__": sample() diff --git a/pairtools/pairtools_select.py b/pairtools/pairtools_select.py index 0ad24287..702e59a7 100644 --- a/pairtools/pairtools_select.py +++ b/pairtools/pairtools_select.py @@ -4,35 +4,29 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options -UTIL_NAME = 'pairtools_select' - -@cli.command() -@click.argument( - 'condition', - type=str -) - -@click.argument( - 'pairs_path', - type=str, - required=False) +UTIL_NAME = "pairtools_select" +@cli.command() +@click.argument("condition", type=str) +@click.argument("pairs_path", type=str, required=False) @click.option( - '-o', "--output", - type=str, - default="", - help='output file.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) @click.option( - "--output-rest", - type=str, - default="", - help='output file for pairs of other types. ' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' By default, such pairs are dropped.') + "--output-rest", + type=str, + default="", + help="output file for pairs of other types. " + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, such pairs are dropped.", +) # Deprecated option to be removed in the future: # @click.option( @@ -42,50 +36,53 @@ # help="Which of the outputs should receive header and comment lines", # show_default=True) + @click.option( - "--chrom-subset", + "--chrom-subset", type=str, - default=None, + default=None, help="A path to a chromosomes file (tab-separated, 1st column contains " "chromosome names) containing a chromosome subset of interest. " "If provided, additionally filter pairs with both sides originating from " "the provided subset of chromosomes. This operation modifies the #chromosomes: " - "and #chromsize: header fields accordingly." - ) - + "and #chromsize: header fields accordingly.", +) @click.option( "--startup-code", type=str, - default=None, + default=None, help="An auxiliary code to execute before filtering. " - "Use to define functions that can be evaluated in the CONDITION statement" - ) - + "Use to define functions that can be evaluated in the CONDITION statement", +) @click.option( - "-t", "--type-cast", - type=(str,str), - default=(), + "-t", + "--type-cast", + type=(str, str), + default=(), multiple=True, - help="Cast a given column to a given type. By default, only pos and mapq " - "are cast to int, other columns are kept as str. Provide as " - "-t , e.g. -t read_len1 int. Multiple entries are allowed." - ) - + help="Cast a given column to a given type. By default, only pos and mapq " + "are cast to int, other columns are kept as str. Provide as " + "-t , e.g. -t read_len1 int. Multiple entries are allowed.", +) @common_io_options - def select( - condition, pairs_path, output, output_rest, #send_comments_to, - chrom_subset, startup_code, type_cast, + condition, + pairs_path, + output, + output_rest, # send_comments_to, + chrom_subset, + startup_code, + type_cast, **kwargs - ): - '''Select pairs according to some condition. +): + """Select pairs according to some condition. CONDITION : A Python expression; if it returns True, select the read pair. - Any column declared in the #columns line of the pairs header can be + Any column declared in the #columns line of the pairs header can be accessed by its name. If the header lacks the #columns line, the columns - are assumed to follow the .pairs/.pairsam standard (readID, chrom1, chrom2, - pos1, pos2, strand1, strand2, pair_type). Finally, CONDITION has access to - COLS list which contains the string values of columns. In Bash, quote + are assumed to follow the .pairs/.pairsam standard (readID, chrom1, chrom2, + pos1, pos2, strand1, strand2, pair_type). Finally, CONDITION has access to + COLS list which contains the string values of columns. In Bash, quote CONDITION with single quotes, and use double quotes for string variables inside CONDITION. @@ -114,35 +111,55 @@ def select( pairtools select 'True' --chr-subset mm9.reduced.chromsizes - ''' + """ select_py( - condition, pairs_path, output, output_rest, #send_comments_to, - chrom_subset, startup_code, type_cast, + condition, + pairs_path, + output, + output_rest, # send_comments_to, + chrom_subset, + startup_code, + type_cast, **kwargs ) - + + def select_py( - condition, pairs_path, output, output_rest, #send_comments_to, - chrom_subset, - startup_code, type_cast, + condition, + pairs_path, + output, + output_rest, # send_comments_to, + chrom_subset, + startup_code, + type_cast, **kwargs - ): +): - instream = _fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + instream = _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) # Optional output created only if requested: outstream_rest = None if output_rest: - outstream_rest = _fileio.auto_open(output_rest, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + outstream_rest = _fileio.auto_open( + output_rest, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) wildcard_library = {} + def wildcard_match(x, wildcard): if wildcard not in wildcard_library: regex = fnmatch.translate(wildcard) @@ -151,26 +168,25 @@ def wildcard_match(x, wildcard): return wildcard_library[wildcard].fullmatch(x) csv_library = {} + def csv_match(x, csv): if csv not in csv_library: - csv_library[csv] = set(csv.split(',')) + csv_library[csv] = set(csv.split(",")) return x in csv_library[csv] regex_library = {} + def regex_match(x, regex): if regex not in regex_library: reobj = re.compile(regex) regex_library[regex] = reobj return regex_library[regex].fullmatch(x) - + new_chroms = None if chrom_subset is not None: - new_chroms = [l.strip().split('\t')[0] for l in open(chrom_subset, 'r')] + new_chroms = [l.strip().split("\t")[0] for l in open(chrom_subset, "r")] - TYPES = {'pos1':'int', - 'pos2':'int', - 'mapq1':'int', - 'mapq2':'int'} + TYPES = {"pos1": "int", "pos2": "int", "mapq1": "int", "mapq2": "int"} TYPES.update(dict(type_cast)) @@ -178,9 +194,9 @@ def regex_match(x, regex): header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) if new_chroms is not None: header = _headerops.subset_chroms_in_pairsheader(header, new_chroms) - outstream.writelines((l+'\n' for l in header)) + outstream.writelines((l + "\n" for l in header)) if output_rest: - outstream_rest.writelines((l+'\n' for l in header)) + outstream_rest.writelines((l + "\n" for l in header)) column_names = _headerops.extract_column_names(header) if len(column_names) == 0: @@ -191,17 +207,18 @@ def regex_match(x, regex): condition = condition.strip() if new_chroms is not None: - condition = ('({}) and (chrom1 in new_chroms) ' - 'and (chrom2 in new_chroms)').format(condition) + condition = ( + "({}) and (chrom1 in new_chroms) " "and (chrom2 in new_chroms)" + ).format(condition) - for i,col in enumerate(column_names): + for i, col in enumerate(column_names): if col in TYPES: col_type = TYPES[col] - condition = condition.replace(col, '{}(COLS[{}])'.format(col_type,i)) + condition = condition.replace(col, "{}(COLS[{}])".format(col_type, i)) else: - condition = condition.replace(col, 'COLS[{}]'.format(i)) + condition = condition.replace(col, "COLS[{}]".format(i)) - match_func = compile(condition, '', 'eval') + match_func = compile(condition, "", "eval") for line in body_stream: COLS = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) @@ -219,5 +236,6 @@ def regex_match(x, regex): if output_rest and outstream_rest != sys.stdout: outstream_rest.close() -if __name__ == '__main__': + +if __name__ == "__main__": select() diff --git a/pairtools/pairtools_sort.py b/pairtools/pairtools_sort.py index 66756251..64972dc4 100644 --- a/pairtools/pairtools_sort.py +++ b/pairtools/pairtools_sort.py @@ -9,102 +9,101 @@ from . import _fileio, _pairsam_format, cli, _headerops, common_io_options -UTIL_NAME = 'pairtools_sort' +UTIL_NAME = "pairtools_sort" -@cli.command() - -@click.argument( - 'pairs_path', - type=str, - required=False) +@cli.command() +@click.argument("pairs_path", type=str, required=False) @click.option( - '-o', "--output", - type=str, - default="", - help='output pairs file.' - ' If the path ends with .gz or .lz4, the output is compressed by bgzip ' - 'or lz4, correspondingly. By default, the output is printed into stdout.') - + "-o", + "--output", + type=str, + default="", + help="output pairs file." + " If the path ends with .gz or .lz4, the output is compressed by bgzip " + "or lz4, correspondingly. By default, the output is printed into stdout.", +) @click.option( - "--nproc", - type=int, - default=8, + "--nproc", + type=int, + default=8, show_default=True, - help='Number of processes to split the sorting work between.' - ) - + help="Number of processes to split the sorting work between.", +) @click.option( - "--tmpdir", - type=str, - default='', - help='Custom temporary folder for sorting intermediates.' - ) - + "--tmpdir", + type=str, + default="", + help="Custom temporary folder for sorting intermediates.", +) @click.option( - "--memory", - type=str, - default='2G', + "--memory", + type=str, + default="2G", show_default=True, - help='The amount of memory used by default.', - - ) - + help="The amount of memory used by default.", +) @click.option( "--compress-program", type=str, - default='auto', + default="auto", show_default=True, - help='A binary to compress temporary sorted chunks. ' - 'Must decompress input when the flag -d is provided. ' - 'Suggested alternatives: gzip, lzop, lz4c, snzip. ' - 'If "auto", then use lz4c if available, and gzip ' - 'otherwise.' - ) - + help="A binary to compress temporary sorted chunks. " + "Must decompress input when the flag -d is provided. " + "Suggested alternatives: gzip, lzop, lz4c, snzip. " + 'If "auto", then use lz4c if available, and gzip ' + "otherwise.", +) @common_io_options - def sort(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): - '''Sort a .pairs/.pairsam file. - - Sort pairs in the lexicographic order along chrom1 and chrom2, in the - numeric order along pos1 and pos2 and in the lexicographic order along + """Sort a .pairs/.pairsam file. + + Sort pairs in the lexicographic order along chrom1 and chrom2, in the + numeric order along pos1 and pos2 and in the lexicographic order along pair_type. - PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the - input is decompressed by bgzip or lz4c, correspondingly. By default, the + PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the + input is decompressed by bgzip or lz4c, correspondingly. By default, the input is read as text from stdin. - ''' + """ sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs) + def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): - instream = _fileio.auto_open(pairs_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) - outstream = _fileio.auto_open(output, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + instream = _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) header = _headerops.mark_header_as_sorted(header) - outstream.writelines((l+'\n' for l in header)) + outstream.writelines((l + "\n" for l in header)) outstream.flush() - - if compress_program == 'auto': - if shutil.which('lz4c') is not None: - compress_program = 'lz4c' + + if compress_program == "auto": + if shutil.which("lz4c") is not None: + compress_program = "lz4c" else: warnings.warn( - 'lz4c is not found. Using gzip for compression of sorted chunks, ' - 'which results in a minor decrease in performance. Please install ' - 'lz4c for faster sorting.') - compress_program = 'gzip' + "lz4c is not found. Using gzip for compression of sorted chunks, " + "which results in a minor decrease in performance. Please install " + "lz4c for faster sorting." + ) + compress_program = "gzip" - command = r''' + command = r""" /bin/bash -c 'export LC_COLLATE=C; export LANG=C; sort -k {0},{0} -k {1},{1} -k {2},{2}n -k {3},{3}n -k {4},{4} --stable @@ -113,26 +112,30 @@ def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwarg {7} -S {8} {9} - '''.replace('\n',' ').format( - _pairsam_format.COL_C1+1, - _pairsam_format.COL_C2+1, - _pairsam_format.COL_P1+1, - _pairsam_format.COL_P2+1, - _pairsam_format.COL_PTYPE+1, - _pairsam_format.PAIRSAM_SEP_ESCAPE, - ' --parallel={} '.format(nproc) if nproc > 0 else ' ', - ' --temporary-directory={} '.format(tmpdir) if tmpdir else ' ', - memory, - (' --compress-program={} '.format(compress_program) - if compress_program else ' '), - - ) + """.replace( + "\n", " " + ).format( + _pairsam_format.COL_C1 + 1, + _pairsam_format.COL_C2 + 1, + _pairsam_format.COL_P1 + 1, + _pairsam_format.COL_P2 + 1, + _pairsam_format.COL_PTYPE + 1, + _pairsam_format.PAIRSAM_SEP_ESCAPE, + " --parallel={} ".format(nproc) if nproc > 0 else " ", + " --temporary-directory={} ".format(tmpdir) if tmpdir else " ", + memory, + ( + " --compress-program={} ".format(compress_program) + if compress_program + else " " + ), + ) command += "'" with subprocess.Popen( - command, stdin=subprocess.PIPE, bufsize=-1, shell=True, - stdout=outstream) as process: - stdin_wrapper = io.TextIOWrapper(process.stdin, 'utf-8') + command, stdin=subprocess.PIPE, bufsize=-1, shell=True, stdout=outstream + ) as process: + stdin_wrapper = io.TextIOWrapper(process.stdin, "utf-8") for line in body_stream: stdin_wrapper.write(line) stdin_wrapper.flush() @@ -145,5 +148,5 @@ def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwarg outstream.close() -if __name__ == '__main__': +if __name__ == "__main__": sort() diff --git a/pairtools/pairtools_split.py b/pairtools/pairtools_split.py index 8bf5e287..f8c23de1 100644 --- a/pairtools/pairtools_split.py +++ b/pairtools/pairtools_split.py @@ -6,68 +6,74 @@ from . import _fileio, _pairsam_format, _headerops, cli, common_io_options -UTIL_NAME = 'pairtools_split' +UTIL_NAME = "pairtools_split" -@cli.command() -@click.argument( - 'pairsam_path', - type=str, - required=False) +@cli.command() +@click.argument("pairsam_path", type=str, required=False) @click.option( - "--output-pairs", - type=str, - default="", - help='output pairs file.' - ' If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed.' - ' If -, pairs are printed to stdout.' - ' If not specified, pairs are dropped.') + "--output-pairs", + type=str, + default="", + help="output pairs file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " If -, pairs are printed to stdout." + " If not specified, pairs are dropped.", +) @click.option( - "--output-sam", - type=str, - default="", - help='output sam file.' - ' If the path ends with .bam, the output is compressed into a bam file.' - ' If -, sam entries are printed to stdout.' - ' If not specified, sam entries are dropped.') - + "--output-sam", + type=str, + default="", + help="output sam file." + " If the path ends with .bam, the output is compressed into a bam file." + " If -, sam entries are printed to stdout." + " If not specified, sam entries are dropped.", +) @common_io_options - def split(pairsam_path, output_pairs, output_sam, **kwargs): - '''Split a .pairsam file into .pairs and .sam. + """Split a .pairsam file into .pairs and .sam. - Restore a .sam file from sam1 and sam2 fields of a .pairsam file. Create + Restore a .sam file from sam1 and sam2 fields of a .pairsam file. Create a .pairs file without sam1/sam2 fields. PAIRSAM_PATH : input .pairsam file. If the path ends with .gz or .lz4, the - input is decompressed by bgzip or lz4c. By default, the input is read from + input is decompressed by bgzip or lz4c. By default, the input is read from stdin. - ''' + """ split_py(pairsam_path, output_pairs, output_sam, **kwargs) def split_py(pairsam_path, output_pairs, output_sam, **kwargs): - instream = _fileio.auto_open(pairsam_path, mode='r', - nproc=kwargs.get('nproc_in'), - command=kwargs.get('cmd_in', None)) + instream = _fileio.auto_open( + pairsam_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) # Output streams if (not output_pairs) and (not output_sam): - raise ValueError('At least one output (pairs and/or sam) must be specified!') - if (output_pairs == '-') and (output_sam == '-'): - raise ValueError('Only one output (pairs or sam) can be printed in stdout!') + raise ValueError("At least one output (pairs and/or sam) must be specified!") + if (output_pairs == "-") and (output_sam == "-"): + raise ValueError("Only one output (pairs or sam) can be printed in stdout!") outstream_pairs = None outstream_sam = None if output_pairs: - outstream_pairs = _fileio.auto_open(output_pairs, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + outstream_pairs = _fileio.auto_open( + output_pairs, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) if output_sam: - outstream_sam = _fileio.auto_open(output_sam, mode='w', - nproc=kwargs.get('nproc_out'), - command=kwargs.get('cmd_out', None)) + outstream_sam = _fileio.auto_open( + output_sam, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) header, body_stream = _headerops.get_header(instream) header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) @@ -76,17 +82,19 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): has_sams = False if columns: # trust the column order specified in the header - if ('sam1' in columns) and ('sam2' in columns): - sam1col = columns.index('sam1') - sam2col = columns.index('sam2') + if ("sam1" in columns) and ("sam2" in columns): + sam1col = columns.index("sam1") + sam2col = columns.index("sam2") columns.pop(max(sam1col, sam2col)) columns.pop(min(sam1col, sam2col)) header = _headerops._update_header_entry( - header, 'columns', ' '.join(columns)) + header, "columns", " ".join(columns) + ) has_sams = True - elif ('sam1' in columns) != ('sam1' in columns): + elif ("sam1" in columns) != ("sam1" in columns): raise ValueError( - 'According to the #columns header field only one sam entry is present') + "According to the #columns header field only one sam entry is present" + ) else: # assume that the file has sam columns and follows the pairsam format sam1col = _pairsam_format.COL_SAM1 @@ -94,10 +102,11 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): has_sams = True if output_pairs: - outstream_pairs.writelines((l+'\n' for l in header)) + outstream_pairs.writelines((l + "\n" for l in header)) if output_sam: outstream_sam.writelines( - (l[11:].strip()+'\n' for l in header if l.startswith('#samheader:'))) + (l[11:].strip() + "\n" for l in header if l.startswith("#samheader:")) + ) # Split sam1 = None @@ -114,15 +123,17 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): if output_pairs: # hard-coded tab separator to follow the DCIC pairs standard - outstream_pairs.write('\t'.join(cols)) - outstream_pairs.write('\n') - - if (output_sam and has_sams): + outstream_pairs.write("\t".join(cols)) + outstream_pairs.write("\n") + + if output_sam and has_sams: for col in (sam1, sam2): - if col != '.': + if col != ".": for sam_entry in col.split(_pairsam_format.INTER_SAM_SEP): - outstream_sam.write(sam_entry.replace(_pairsam_format.SAM_SEP,'\t')) - outstream_sam.write('\n') + outstream_sam.write( + sam_entry.replace(_pairsam_format.SAM_SEP, "\t") + ) + outstream_sam.write("\n") if output_pairs and outstream_pairs != sys.stdout: outstream_pairs.close() @@ -131,5 +142,5 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): outstream_sam.close() -if __name__ == '__main__': +if __name__ == "__main__": split() diff --git a/pairtools/pairtools_stats.py b/pairtools/pairtools_stats.py index 8b844fe8..7328b177 100755 --- a/pairtools/pairtools_stats.py +++ b/pairtools/pairtools_stats.py @@ -27,14 +27,14 @@ ) @common_io_options def stats(input_path, output, merge, **kwargs): - """Calculate pairs statistics. + """Calculate pairs statistics. INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. If not provided, the input is read from stdin. - If --merge is specified, then INPUT_PATH is interpreted as an arbitrary number + If --merge is specified, then INPUT_PATH is interpreted as an arbitrary number of stats files to merge. - - The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. + + The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. """ stats_py(input_path, output, merge, **kwargs) @@ -44,12 +44,18 @@ def stats_py(input_path, output, merge, **kwargs): do_merge(output, input_path, **kwargs) return - instream = _fileio.auto_open(input_path[0], mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None)) - outstream = _fileio.auto_open(output, mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None)) + instream = _fileio.auto_open( + input_path[0], + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) header, body_stream = _headerops.get_header(instream) cols = _headerops.extract_column_names(header) @@ -414,7 +420,7 @@ def add_pair(self, chrom1, pos1, strand1, chrom2, pos2, strand2, pair_type): def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): """Gather statistics for Hi-C pairs in a dataframe and add to the PairCounter. - + Parameters ---------- df: pd.DataFrame @@ -438,7 +444,9 @@ def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): self._stat["total_unmapped"] += int(unmapped_count) # Count the mapped: - df_mapped = df.loc[(df["chrom1"] != unmapped_chrom) & (df["chrom2"] != unmapped_chrom), :] + df_mapped = df.loc[ + (df["chrom1"] != unmapped_chrom) & (df["chrom2"] != unmapped_chrom), : + ] mapped_count = df_mapped.shape[0] self._stat["total_mapped"] += mapped_count @@ -535,9 +543,7 @@ def __radd__(self, other): return self.__add__(other) def flatten(self): - """return a flattened dict (formatted same way as .stats file) - - """ + """return a flattened dict (formatted same way as .stats file)""" # dict for flat store: flat_stat = {} @@ -610,4 +616,3 @@ def save(self, outstream): if __name__ == "__main__": stats() - diff --git a/tests/test_dedup.py b/tests/test_dedup.py index 71b14386..43aaef0b 100644 --- a/tests/test_dedup.py +++ b/tests/test_dedup.py @@ -6,111 +6,132 @@ import tempfile testdir = os.path.dirname(os.path.realpath(__file__)) -mock_pairsam_path = os.path.join(testdir, 'data', 'mock.4dedup.pairsam') +mock_pairsam_path = os.path.join(testdir, "data", "mock.4dedup.pairsam") tmpdir = tempfile.TemporaryDirectory() tmpdir_name = tmpdir.name -dedup_path = os.path.join(tmpdir_name, 'dedup.pairsam') -unmapped_path = os.path.join(tmpdir_name, 'unmapped.pairsam') -dups_path = os.path.join(tmpdir_name, 'dups.pairsam') +dedup_path = os.path.join(tmpdir_name, "dedup.pairsam") +unmapped_path = os.path.join(tmpdir_name, "unmapped.pairsam") +dups_path = os.path.join(tmpdir_name, "dups.pairsam") -dedup_max_path = os.path.join(tmpdir_name, 'dedup_max.pairsam') -unmapped_max_path = os.path.join(tmpdir_name, 'unmapped_max.pairsam') -dups_max_path = os.path.join(tmpdir_name, 'dups_max.pairsam') +dedup_max_path = os.path.join(tmpdir_name, "dedup_max.pairsam") +unmapped_max_path = os.path.join(tmpdir_name, "unmapped_max.pairsam") +dups_max_path = os.path.join(tmpdir_name, "dups_max.pairsam") -dedup_markdups_path = os.path.join(tmpdir_name, 'dedup.markdups.pairsam') -unmapped_markdups_path = os.path.join(tmpdir_name, 'unmapped.markdups.pairsam') -dups_markdups_path = os.path.join(tmpdir_name, 'dups.markdups.pairsam') +dedup_markdups_path = os.path.join(tmpdir_name, "dedup.markdups.pairsam") +unmapped_markdups_path = os.path.join(tmpdir_name, "unmapped.markdups.pairsam") +dups_markdups_path = os.path.join(tmpdir_name, "dups.markdups.pairsam") max_mismatch = 1 + + def setup_func(): try: subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'dedup', - mock_pairsam_path, - '--output', - dedup_path, - '--output-dups', - dups_path, - '--output-unmapped', - unmapped_path, - '--max-mismatch', - str(max_mismatch) - ], - ) + [ + "python", + "-m", + "pairtools", + "dedup", + mock_pairsam_path, + "--output", + dedup_path, + "--output-dups", + dups_path, + "--output-unmapped", + unmapped_path, + "--max-mismatch", + str(max_mismatch), + ], + ) subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'dedup', - mock_pairsam_path, - '--output', - dedup_max_path, - '--output-dups', - dups_max_path, - '--output-unmapped', - unmapped_max_path, - '--max-mismatch', - str(max_mismatch), - '--method', 'max' - ], - ) + [ + "python", + "-m", + "pairtools", + "dedup", + mock_pairsam_path, + "--output", + dedup_max_path, + "--output-dups", + dups_max_path, + "--output-unmapped", + unmapped_max_path, + "--max-mismatch", + str(max_mismatch), + "--method", + "max", + ], + ) subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'dedup', - mock_pairsam_path, - '--mark-dups', - '--output', - dedup_markdups_path, - '--output-dups', - dups_markdups_path, - '--output-unmapped', - unmapped_markdups_path, - '--max-mismatch', - str(max_mismatch) - ], - ) + [ + "python", + "-m", + "pairtools", + "dedup", + mock_pairsam_path, + "--mark-dups", + "--output", + dedup_markdups_path, + "--output-dups", + dups_markdups_path, + "--output-unmapped", + unmapped_markdups_path, + "--max-mismatch", + str(max_mismatch), + ], + ) except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e + def teardown_func(): tmpdir.cleanup() + @with_setup(setup_func, teardown_func) def test_mock_pairsam(): - pairsam_pairs = [l.strip().split('\t') for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - for (ddp, up, dp) in [(dedup_path, unmapped_path, dups_path), - (dedup_max_path, unmapped_max_path, dups_max_path), - (dedup_markdups_path, - unmapped_markdups_path, - dups_markdups_path)]: - - dedup_pairs = [l.strip().split('\t') for l in open(ddp, 'r') - if not l.startswith('#') and l.strip()] - unmapped_pairs = [l.strip().split('\t') for l in open(up, 'r') - if not l.startswith('#') and l.strip()] - dup_pairs = [l.strip().split('\t') for l in open(dp, 'r') - if not l.startswith('#') and l.strip()] + pairsam_pairs = [ + l.strip().split("\t") + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + for (ddp, up, dp) in [ + (dedup_path, unmapped_path, dups_path), + (dedup_max_path, unmapped_max_path, dups_max_path), + (dedup_markdups_path, unmapped_markdups_path, dups_markdups_path), + ]: + + dedup_pairs = [ + l.strip().split("\t") + for l in open(ddp, "r") + if not l.startswith("#") and l.strip() + ] + unmapped_pairs = [ + l.strip().split("\t") + for l in open(up, "r") + if not l.startswith("#") and l.strip() + ] + dup_pairs = [ + l.strip().split("\t") + for l in open(dp, "r") + if not l.startswith("#") and l.strip() + ] # check that at least a few pairs remained in deduped and dup files assert len(dedup_pairs) > 0 assert len(dup_pairs) > 0 assert len(unmapped_pairs) > 0 import pandas as pd - + # check that all pairsam entries survived deduping: - assert (len(dedup_pairs) + len(unmapped_pairs) - + len(dup_pairs) == len(pairsam_pairs)) + assert len(dedup_pairs) + len(unmapped_pairs) + len(dup_pairs) == len( + pairsam_pairs + ) def pairs_overlap(pair1, pair2, max_mismatch): overlap = ( @@ -120,20 +141,24 @@ def pairs_overlap(pair1, pair2, max_mismatch): and (pair1[6] == pair2[6]) and (abs(int(pair1[2]) - int(pair2[2])) <= max_mismatch) and (abs(int(pair1[4]) - int(pair2[4])) <= max_mismatch) - ) + ) return overlap # check that deduped pairs do not overlap - assert all([not pairs_overlap(pair1, pair2, max_mismatch) - for i, pair1 in enumerate(dedup_pairs) - for j, pair2 in enumerate(dedup_pairs) - if i != j]) + assert all( + [ + not pairs_overlap(pair1, pair2, max_mismatch) + for i, pair1 in enumerate(dedup_pairs) + for j, pair2 in enumerate(dedup_pairs) + if i != j + ] + ) - # check that the removed duplicates overlap with at least one of the + # check that the removed duplicates overlap with at least one of the # deduplicated entries - assert all([ - any([pairs_overlap(pair1, pair2, 3) - for pair2 in dedup_pairs]) - for pair1 in dup_pairs - ]) - + assert all( + [ + any([pairs_overlap(pair1, pair2, 3) for pair2 in dedup_pairs]) + for pair1 in dup_pairs + ] + ) diff --git a/tests/test_filterbycov.py b/tests/test_filterbycov.py index 891027d3..50f07685 100644 --- a/tests/test_filterbycov.py +++ b/tests/test_filterbycov.py @@ -7,120 +7,127 @@ testdir = os.path.dirname(os.path.realpath(__file__)) -mock_pairs_path = os.path.join(testdir, 'data', 'mock.4filterbycov.pairs') +mock_pairs_path = os.path.join(testdir, "data", "mock.4filterbycov.pairs") tmpdir = tempfile.TemporaryDirectory() tmpdir_name = tmpdir.name params = [ - {'max_dist': 0, - 'max_cov' : 3}, - {'max_dist': 0, - 'max_cov' : 2}, - {'max_dist': 1, - 'max_cov' : 1}, - ] + {"max_dist": 0, "max_cov": 3}, + {"max_dist": 0, "max_cov": 2}, + {"max_dist": 1, "max_cov": 1}, +] for p in params: - p['lowcov_path'] = os.path.join( - tmpdir_name, - 'lowcov.{}.{}.pairs'.format(p['max_dist'], p['max_cov']) - ) - p['highcov_path'] = os.path.join( - tmpdir_name, - 'highcov.{}.{}.pairs'.format(p['max_dist'], p['max_cov']) - ) - p['unmapped_path'] = os.path.join( - tmpdir_name, - 'unmapped.{}.{}.pairs'.format(p['max_dist'], p['max_cov']) - ) + p["lowcov_path"] = os.path.join( + tmpdir_name, "lowcov.{}.{}.pairs".format(p["max_dist"], p["max_cov"]) + ) + p["highcov_path"] = os.path.join( + tmpdir_name, "highcov.{}.{}.pairs".format(p["max_dist"], p["max_cov"]) + ) + p["unmapped_path"] = os.path.join( + tmpdir_name, "unmapped.{}.{}.pairs".format(p["max_dist"], p["max_cov"]) + ) + def setup_func(): try: for p in params: subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'filterbycov', - mock_pairs_path, - '--output', - p['lowcov_path'], - '--output-highcov', - p['highcov_path'], - '--output-unmapped', - p['unmapped_path'], - '--max-dist', - str(p['max_dist']), - '--max-cov', - str(p['max_cov']), - ] - ) + [ + "python", + "-m", + "pairtools", + "filterbycov", + mock_pairs_path, + "--output", + p["lowcov_path"], + "--output-highcov", + p["highcov_path"], + "--output-unmapped", + p["unmapped_path"], + "--max-dist", + str(p["max_dist"]), + "--max-cov", + str(p["max_cov"]), + ] + ) except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e + def teardown_func(): tmpdir.cleanup() + @with_setup(setup_func, teardown_func) def test_mock_pairs(): - all_pairs = [l.strip().split('\t') - for l in open(mock_pairs_path, 'r') - if not l.startswith('#') and l.strip()] + all_pairs = [ + l.strip().split("\t") + for l in open(mock_pairs_path, "r") + if not l.startswith("#") and l.strip() + ] for p in params: - lowcov_pairs = [l.strip().split('\t') for l in open(p['lowcov_path'], 'r') - if not l.startswith('#') and l.strip()] - highcov_pairs = [l.strip().split('\t') for l in open(p['highcov_path'], 'r') - if not l.startswith('#') and l.strip()] - unmapped_pairs = [l.strip().split('\t') for l in open(p['unmapped_path'], 'r') - if not l.startswith('#') and l.strip()] + lowcov_pairs = [ + l.strip().split("\t") + for l in open(p["lowcov_path"], "r") + if not l.startswith("#") and l.strip() + ] + highcov_pairs = [ + l.strip().split("\t") + for l in open(p["highcov_path"], "r") + if not l.startswith("#") and l.strip() + ] + unmapped_pairs = [ + l.strip().split("\t") + for l in open(p["unmapped_path"], "r") + if not l.startswith("#") and l.strip() + ] # check that at least a few pairs remained in deduped and dup files - #assert len(lowcov_pairs) > 0 - #assert len(highcov_pairs) > 0 - #assert len(unmapped_pairs) > 0 + # assert len(lowcov_pairs) > 0 + # assert len(highcov_pairs) > 0 + # assert len(unmapped_pairs) > 0 # check that all pairs entries survived deduping: - assert (len(lowcov_pairs) + len(unmapped_pairs) - + len(highcov_pairs) == len(all_pairs)) + assert len(lowcov_pairs) + len(unmapped_pairs) + len(highcov_pairs) == len( + all_pairs + ) - assert all([(pair[1] != '!' and pair[3] != '!') for pair in lowcov_pairs]) - assert all([(pair[1] != '!' and pair[3] != '!') for pair in highcov_pairs]) - assert all([(pair[1] == '!' or pair[3] == '!') for pair in unmapped_pairs]) + assert all([(pair[1] != "!" and pair[3] != "!") for pair in lowcov_pairs]) + assert all([(pair[1] != "!" and pair[3] != "!") for pair in highcov_pairs]) + assert all([(pair[1] == "!" or pair[3] == "!") for pair in unmapped_pairs]) def update_coverage(coverage, chrom, pos, max_dist): - if chrom == '!': + if chrom == "!": return coverage[chrom] = coverage.get(chrom, {}) - for i in range(max(0, pos-max_dist), pos+max_dist+1): - coverage[chrom][i] = coverage[chrom].get(i,0) + 1 - + for i in range(max(0, pos - max_dist), pos + max_dist + 1): + coverage[chrom][i] = coverage[chrom].get(i, 0) + 1 + coverage = {} for pair in all_pairs: - update_coverage(coverage, pair[1], int(pair[2]), p['max_dist']) - update_coverage(coverage, pair[3], int(pair[4]), p['max_dist']) + update_coverage(coverage, pair[1], int(pair[2]), p["max_dist"]) + update_coverage(coverage, pair[3], int(pair[4]), p["max_dist"]) for pair in lowcov_pairs: - #print (p['max_cov'],p['max_dist']) - #print (pair, coverage[pair[1]][int(pair[2])]) - #print (pair, coverage[pair[3]][int(pair[4])]) - assert (coverage[pair[1]][int(pair[2])] <= p['max_cov']) - assert (coverage[pair[3]][int(pair[4])] <= p['max_cov']) + # print (p['max_cov'],p['max_dist']) + # print (pair, coverage[pair[1]][int(pair[2])]) + # print (pair, coverage[pair[3]][int(pair[4])]) + assert coverage[pair[1]][int(pair[2])] <= p["max_cov"] + assert coverage[pair[3]][int(pair[4])] <= p["max_cov"] for pair in highcov_pairs: - #print (p['max_cov'],p['max_dist']) - #print (pair, coverage[pair[1]][int(pair[2])]) - #print (pair, coverage[pair[3]][int(pair[4])]) - assert ( - (coverage[pair[1]][int(pair[2])] > p['max_cov']) - or - (coverage[pair[3]][int(pair[4])] > p['max_cov']) + # print (p['max_cov'],p['max_dist']) + # print (pair, coverage[pair[1]][int(pair[2])]) + # print (pair, coverage[pair[3]][int(pair[4])]) + assert (coverage[pair[1]][int(pair[2])] > p["max_cov"]) or ( + coverage[pair[3]][int(pair[4])] > p["max_cov"] ) - diff --git a/tests/test_flip.py b/tests/test_flip.py index c69a1e6c..9c6b468a 100644 --- a/tests/test_flip.py +++ b/tests/test_flip.py @@ -5,55 +5,54 @@ from nose.tools import assert_raises testdir = os.path.dirname(os.path.realpath(__file__)) -mock_pairs_path = os.path.join(testdir, 'data', 'mock.4flip.pairs') -mock_chromsizes_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') +mock_pairs_path = os.path.join(testdir, "data", "mock.4flip.pairs") +mock_chromsizes_path = os.path.join(testdir, "data", "mock.chrom.sizes") def test_flip(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'flip', - mock_pairs_path, - '-c', - mock_chromsizes_path - ], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "flip", + mock_pairs_path, + "-c", + mock_chromsizes_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - - orig_pairs = [l.strip().split('\t') - for l in open(mock_pairs_path, 'r') - if not l.startswith('#') and l.strip()] - flipped_pairs = [l.strip().split('\t') - for l in result.split('\n') - if not l.startswith('#') and l.strip()] - - chrom_enum = {'!':0, 'chr1':1, 'chr2': 2, 'chrU':3, 'chrU1': 4} + orig_pairs = [ + l.strip().split("\t") + for l in open(mock_pairs_path, "r") + if not l.startswith("#") and l.strip() + ] + flipped_pairs = [ + l.strip().split("\t") + for l in result.split("\n") + if not l.startswith("#") and l.strip() + ] + + chrom_enum = {"!": 0, "chr1": 1, "chr2": 2, "chrU": 3, "chrU1": 4} # chrU stands for unannotated chromosome, which has less priority than annotated ones # chrU1 is another unannotated chromosome, which should go lexigographically after chrU for orig_pair, flipped_pair in zip(orig_pairs, flipped_pairs): - has_correct_order = ( - (chrom_enum[orig_pair[1]], int(orig_pair[2])) - <= (chrom_enum[orig_pair[3]], int(orig_pair[4])) - ) + has_correct_order = (chrom_enum[orig_pair[1]], int(orig_pair[2])) <= ( + chrom_enum[orig_pair[3]], + int(orig_pair[4]), + ) if has_correct_order: - assert(all([c1==c2 for c1,c2 in zip(orig_pair, flipped_pair)])) + assert all([c1 == c2 for c1, c2 in zip(orig_pair, flipped_pair)]) if not has_correct_order: - assert(orig_pair[1] == flipped_pair[3]) - assert(orig_pair[2] == flipped_pair[4]) - assert(orig_pair[3] == flipped_pair[1]) - assert(orig_pair[4] == flipped_pair[2]) - assert(orig_pair[5] == flipped_pair[6]) - assert(orig_pair[6] == flipped_pair[5]) - assert(orig_pair[7] == flipped_pair[7][::-1]) - - - - - + assert orig_pair[1] == flipped_pair[3] + assert orig_pair[2] == flipped_pair[4] + assert orig_pair[3] == flipped_pair[1] + assert orig_pair[4] == flipped_pair[2] + assert orig_pair[5] == flipped_pair[6] + assert orig_pair[6] == flipped_pair[5] + assert orig_pair[7] == flipped_pair[7][::-1] diff --git a/tests/test_headerops.py b/tests/test_headerops.py index be75ceb8..9b3d9ba7 100644 --- a/tests/test_headerops.py +++ b/tests/test_headerops.py @@ -3,37 +3,38 @@ from nose.tools import assert_raises, with_setup, raises + def test_make_standard_header(): header = _headerops.make_standard_pairsheader() - assert any([l.startswith('## pairs format') for l in header]) - assert any([l.startswith('#shape') for l in header]) - assert any([l.startswith('#columns') for l in header]) + assert any([l.startswith("## pairs format") for l in header]) + assert any([l.startswith("#shape") for l in header]) + assert any([l.startswith("#columns") for l in header]) header = _headerops.make_standard_pairsheader( - chromsizes=[('b', 100), ('c', 100), ('a', 100)]) + chromsizes=[("b", 100), ("c", 100), ("a", 100)] + ) + + assert sum([l.startswith("#chromsize") for l in header]) == 3 - assert sum([l.startswith('#chromsize') for l in header]) == 3 def test_samheaderops(): header = _headerops.make_standard_pairsheader() samheader = [ - '@SQ\tSN:chr1\tLN:100', - '@SQ\tSN:chr2\tLN:100', - '@SQ\tSN:chr3\tLN:100', - '@PG\tID:bwa\tPN:bwa\tCL:bwa', - '@PG\tID:bwa-2\tPN:bwa\tCL:bwa\tPP:bwa' + "@SQ\tSN:chr1\tLN:100", + "@SQ\tSN:chr2\tLN:100", + "@SQ\tSN:chr3\tLN:100", + "@PG\tID:bwa\tPN:bwa\tCL:bwa", + "@PG\tID:bwa-2\tPN:bwa\tCL:bwa\tPP:bwa", ] header_with_sam = _headerops.insert_samheader(header, samheader) - + assert len(header_with_sam) == len(header) + len(samheader) for l in samheader: - assert any([l2.startswith('#samheader') and l in l2 - for l2 in header_with_sam]) + assert any([l2.startswith("#samheader") and l in l2 for l2 in header_with_sam]) # test adding new programs to the PG chain - header_extra_pg = _headerops.append_new_pg( - header_with_sam, ID='test', PN='test') + header_extra_pg = _headerops.append_new_pg(header_with_sam, ID="test", PN="test") # test if all lines got transferred assert all([(old_l in header_extra_pg) for old_l in header_with_sam]) @@ -42,106 +43,105 @@ def test_samheaderops(): # test if the new PG has PP matching the ID of one of already existing PGs new_l = [l for l in header_extra_pg if l not in header_with_sam][0] - pp = [f[3:] for f in new_l.split('\t') if f.startswith('PP:')][0] - assert len([l for l in header_extra_pg - if l.startswith('#samheader') - and ('\tID:{}\t'.format(pp) in l) - ]) == 1 + pp = [f[3:] for f in new_l.split("\t") if f.startswith("PP:")][0] + assert ( + len( + [ + l + for l in header_extra_pg + if l.startswith("#samheader") and ("\tID:{}\t".format(pp) in l) + ] + ) + == 1 + ) def test_merge_pairheaders(): - headers = [ - ['## pairs format v1.0'], - ['## pairs format v1.0'] - ] + headers = [["## pairs format v1.0"], ["## pairs format v1.0"]] merged_header = _headerops._merge_pairheaders(headers) assert merged_header == headers[0] - headers = [ - ['## pairs format v1.0', - '#a'], - ['## pairs format v1.0', - '#b'] - ] + headers = [["## pairs format v1.0", "#a"], ["## pairs format v1.0", "#b"]] merged_header = _headerops._merge_pairheaders(headers) - assert merged_header == ['## pairs format v1.0', - '#a', - '#b'] + assert merged_header == ["## pairs format v1.0", "#a", "#b"] headers = [ - ['## pairs format v1.0', - '#chromsize: chr1 100', - '#chromsize: chr2 200'], - ['## pairs format v1.0', - '#chromsize: chr1 100', - '#chromsize: chr2 200'], + ["## pairs format v1.0", "#chromsize: chr1 100", "#chromsize: chr2 200"], + ["## pairs format v1.0", "#chromsize: chr1 100", "#chromsize: chr2 200"], ] merged_header = _headerops._merge_pairheaders(headers) assert merged_header == headers[0] + @raises(Exception) def test_merge_different_pairheaders(): - headers = [ - ['## pairs format v1.0'], - ['## pairs format v1.1'] - ] + headers = [["## pairs format v1.0"], ["## pairs format v1.1"]] merged_header = _headerops._merge_pairheaders(headers) + def test_force_merge_pairheaders(): headers = [ - ['## pairs format v1.0', - '#chromsize: chr1 100'], - ['## pairs format v1.0', - '#chromsize: chr2 200'], + ["## pairs format v1.0", "#chromsize: chr1 100"], + ["## pairs format v1.0", "#chromsize: chr2 200"], ] merged_header = _headerops._merge_pairheaders(headers, force=True) - assert merged_header == ['## pairs format v1.0', - '#chromsize: chr1 100', - '#chromsize: chr2 200'] + assert merged_header == [ + "## pairs format v1.0", + "#chromsize: chr1 100", + "#chromsize: chr2 200", + ] + def test_merge_samheaders(): headers = [ - ['@HD\tVN:1'], - ['@HD\tVN:1'], + ["@HD\tVN:1"], + ["@HD\tVN:1"], ] merged_header = _headerops._merge_samheaders(headers) assert merged_header == headers[0] headers = [ - ['@HD\tVN:1', - '@SQ\tSN:chr1\tLN:100', - '@SQ\tSN:chr2\tLN:100', + [ + "@HD\tVN:1", + "@SQ\tSN:chr1\tLN:100", + "@SQ\tSN:chr2\tLN:100", ], - ['@HD\tVN:1', - '@SQ\tSN:chr1\tLN:100', - '@SQ\tSN:chr2\tLN:100', + [ + "@HD\tVN:1", + "@SQ\tSN:chr1\tLN:100", + "@SQ\tSN:chr2\tLN:100", ], ] merged_header = _headerops._merge_samheaders(headers) assert merged_header == headers[0] headers = [ - ['@HD\tVN:1', - '@PG\tID:bwa\tPN:bwa\tPP:cat', + [ + "@HD\tVN:1", + "@PG\tID:bwa\tPN:bwa\tPP:cat", ], - ['@HD\tVN:1', - '@PG\tID:bwa\tPN:bwa\tPP:cat', + [ + "@HD\tVN:1", + "@PG\tID:bwa\tPN:bwa\tPP:cat", ], ] merged_header = _headerops._merge_samheaders(headers) print(merged_header) assert merged_header == [ - '@HD\tVN:1', - '@PG\tID:bwa-1\tPN:bwa\tPP:cat-1', - '@PG\tID:bwa-2\tPN:bwa\tPP:cat-2', - ] + "@HD\tVN:1", + "@PG\tID:bwa-1\tPN:bwa\tPP:cat-1", + "@PG\tID:bwa-2\tPN:bwa\tPP:cat-2", + ] + def test_merge_headers(): headers = [ - ['## pairs format v1.0', - '#samheader: @HD\tVN:1', - '#samheader: @SQ\tSN:chr1\tLN:100', - '#samheader: @SQ\tSN:chr2\tLN:100'] + [ + "## pairs format v1.0", + "#samheader: @HD\tVN:1", + "#samheader: @SQ\tSN:chr1\tLN:100", + "#samheader: @SQ\tSN:chr2\tLN:100", + ] ] * 2 merged_header = _headerops.merge_headers(headers) diff --git a/tests/test_markasdup.py b/tests/test_markasdup.py index 3f304ff0..891ffb4d 100644 --- a/tests/test_markasdup.py +++ b/tests/test_markasdup.py @@ -6,32 +6,30 @@ testdir = os.path.dirname(os.path.realpath(__file__)) + def test_mock_pairsam(): - mock_pairsam_path = os.path.join(testdir, 'data', 'mock.pairsam') + mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'markasdup', - mock_pairsam_path], - ).decode('ascii') + ["python", "-m", "pairtools", "markasdup", mock_pairsam_path], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] # check that all pairsam entries survived sorting: assert len(pairsam_body) == len(output_body) - + # check that all pairtypes got changed to DD for l in output_body: - assert l.split('\t')[7] == 'DD' - - - + assert l.split("\t")[7] == "DD" diff --git a/tests/test_merge.py b/tests/test_merge.py index 96abacbe..a2be832c 100644 --- a/tests/test_merge.py +++ b/tests/test_merge.py @@ -9,106 +9,127 @@ tmpdir = tempfile.TemporaryDirectory() tmpdir_name = tmpdir.name -mock_pairsam_path_1 = os.path.join(testdir, 'data', 'mock.pairsam') -mock_pairsam_path_2 = os.path.join(testdir, 'data', 'mock.2.pairsam') -mock_sorted_pairsam_path_1 = os.path.join(tmpdir_name, '1.pairsam') -mock_sorted_pairsam_path_2 = os.path.join(tmpdir_name, '2.pairsam') +mock_pairsam_path_1 = os.path.join(testdir, "data", "mock.pairsam") +mock_pairsam_path_2 = os.path.join(testdir, "data", "mock.2.pairsam") +mock_sorted_pairsam_path_1 = os.path.join(tmpdir_name, "1.pairsam") +mock_sorted_pairsam_path_2 = os.path.join(tmpdir_name, "2.pairsam") + def setup_func(): try: subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'sort', - mock_pairsam_path_1, - '--output', - mock_sorted_pairsam_path_1 - ], - ) + [ + "python", + "-m", + "pairtools", + "sort", + mock_pairsam_path_1, + "--output", + mock_sorted_pairsam_path_1, + ], + ) subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'sort', - mock_pairsam_path_2, - '--output', - mock_sorted_pairsam_path_2 - ], - ) + [ + "python", + "-m", + "pairtools", + "sort", + mock_pairsam_path_2, + "--output", + mock_sorted_pairsam_path_2, + ], + ) except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e + def teardown_func(): tmpdir.cleanup() + @with_setup(setup_func, teardown_func) def test_mock_pairsam(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'merge', - mock_sorted_pairsam_path_1, - mock_sorted_pairsam_path_2 - ], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "merge", + mock_sorted_pairsam_path_1, + mock_sorted_pairsam_path_2, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e # check that all pairsam entries survived sorting: - pairsam_body_1 = [l.strip() for l in open(mock_pairsam_path_1, 'r') - if not l.startswith('#') and l.strip()] - pairsam_body_2 = [l.strip() for l in open(mock_pairsam_path_2, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body_1 = [ + l.strip() + for l in open(mock_pairsam_path_1, "r") + if not l.startswith("#") and l.strip() + ] + pairsam_body_2 = [ + l.strip() + for l in open(mock_pairsam_path_2, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] assert len(pairsam_body_1) + len(pairsam_body_2) == len(output_body) # check the sorting order of the output: prev_pair = None for l in output_body: - cur_pair = l.split('\t')[1:8] + cur_pair = l.split("\t")[1:8] if prev_pair is not None: - assert (cur_pair[0] >= prev_pair[0]) - if (cur_pair[0] == prev_pair[0]): - assert (cur_pair[1] >= prev_pair[1]) - if (cur_pair[1] == prev_pair[1]): - assert (cur_pair[2] >= prev_pair[2]) - if (cur_pair[2] == prev_pair[2]): - assert (cur_pair[3] >= prev_pair[3]) + assert cur_pair[0] >= prev_pair[0] + if cur_pair[0] == prev_pair[0]: + assert cur_pair[1] >= prev_pair[1] + if cur_pair[1] == prev_pair[1]: + assert cur_pair[2] >= prev_pair[2] + if cur_pair[2] == prev_pair[2]: + assert cur_pair[3] >= prev_pair[3] prev_pair = cur_pair # Check that the header is preserved: try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'merge', - '--keep-first-header', - mock_sorted_pairsam_path_1, - mock_sorted_pairsam_path_2 - ], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "merge", + "--keep-first-header", + mock_sorted_pairsam_path_1, + mock_sorted_pairsam_path_2, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e # check the headers: - pairsam_header_1 = [l.strip() for l in open(mock_sorted_pairsam_path_1, 'r') - if l.startswith('#') and l.strip()] - pairsam_header_2 = [l.strip() for l in open(mock_sorted_pairsam_path_2, 'r') - if l.startswith('#') and l.strip()] - output_header = [l.strip() for l in result.split('\n') - if l.startswith('#') and l.strip()] + pairsam_header_1 = [ + l.strip() + for l in open(mock_sorted_pairsam_path_1, "r") + if l.startswith("#") and l.strip() + ] + pairsam_header_2 = [ + l.strip() + for l in open(mock_sorted_pairsam_path_2, "r") + if l.startswith("#") and l.strip() + ] + output_header = [ + l.strip() for l in result.split("\n") if l.startswith("#") and l.strip() + ] - assert len(pairsam_header_1)+1 == len(output_header) \ No newline at end of file + assert len(pairsam_header_1) + 1 == len(output_header) diff --git a/tests/test_parse.py b/tests/test_parse.py index 896343bc..02d5e5be 100644 --- a/tests/test_parse.py +++ b/tests/test_parse.py @@ -112,4 +112,3 @@ def test_mock_pysam_parse_all(): print() assert assigned_pair == simulated_pair - diff --git a/tests/test_parse2.py b/tests/test_parse2.py index 7acc37f6..f00387c0 100644 --- a/tests/test_parse2.py +++ b/tests/test_parse2.py @@ -10,49 +10,56 @@ def test_mock_pysam_parse2_read(): - mock_sam_path = os.path.join(testdir, 'data', 'mock.parse2.sam') - mock_chroms_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') + mock_sam_path = os.path.join(testdir, "data", "mock.parse2.sam") + mock_chroms_path = os.path.join(testdir, "data", "mock.chrom.sizes") try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'parse2', - '-c', - mock_chroms_path, - '--add-pair-index', - '--report-position', - 'junction', - '--report-orientation', - 'pair', - mock_sam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "parse2", + "-c", + mock_chroms_path, + "--add-pair-index", + "--report-position", + "junction", + "--report-orientation", + "pair", + mock_sam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e # check if the header got transferred correctly - sam_header = [l.strip() for l in open(mock_sam_path, 'r') if l.startswith('@')] - pairsam_header = [l.strip() for l in result.split('\n') if l.startswith('#')] + sam_header = [l.strip() for l in open(mock_sam_path, "r") if l.startswith("@")] + pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")] for l in sam_header: assert any([l in l2 for l2 in pairsam_header]) # check that the pairs got assigned properly id_counter = 0 - prev_id = '' - for l in result.split('\n'): - if l.startswith('#') or not l: + prev_id = "" + for l in result.split("\n"): + if l.startswith("#") or not l: continue - if prev_id == l.split('\t')[0]: + if prev_id == l.split("\t")[0]: id_counter += 1 else: id_counter = 0 - prev_id = l.split('\t')[0] - - assigned_pair = l.split('\t')[1:8]+[l.split('\t')[-1]] - simulated_pair = l.split('SIMULATED:',1)[1].split('\031',1)[0].split('|')[id_counter].split(',') + prev_id = l.split("\t")[0] + + assigned_pair = l.split("\t")[1:8] + [l.split("\t")[-1]] + simulated_pair = ( + l.split("SIMULATED:", 1)[1] + .split("\031", 1)[0] + .split("|")[id_counter] + .split(",") + ) print(assigned_pair) print(simulated_pair, prev_id) print() @@ -61,49 +68,56 @@ def test_mock_pysam_parse2_read(): def test_mock_pysam_parse2_pair(): - mock_sam_path = os.path.join(testdir, 'data', 'mock.parse-all.sam') - mock_chroms_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') + mock_sam_path = os.path.join(testdir, "data", "mock.parse-all.sam") + mock_chroms_path = os.path.join(testdir, "data", "mock.chrom.sizes") try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'parse2', - '-c', - mock_chroms_path, - '--add-pair-index', - '--report-position', - 'outer', - '--report-orientation', - 'pair', - mock_sam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "parse2", + "-c", + mock_chroms_path, + "--add-pair-index", + "--report-position", + "outer", + "--report-orientation", + "pair", + mock_sam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e # check if the header got transferred correctly - sam_header = [l.strip() for l in open(mock_sam_path, 'r') if l.startswith('@')] - pairsam_header = [l.strip() for l in result.split('\n') if l.startswith('#')] + sam_header = [l.strip() for l in open(mock_sam_path, "r") if l.startswith("@")] + pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")] for l in sam_header: assert any([l in l2 for l2 in pairsam_header]) # check that the pairs got assigned properly id_counter = 0 - prev_id = '' - for l in result.split('\n'): - if l.startswith('#') or not l: + prev_id = "" + for l in result.split("\n"): + if l.startswith("#") or not l: continue - if prev_id == l.split('\t')[0]: + if prev_id == l.split("\t")[0]: id_counter += 1 else: id_counter = 0 - prev_id = l.split('\t')[0] - - assigned_pair = l.split('\t')[1:8]+[l.split('\t')[-1]] - simulated_pair = l.split('SIMULATED:',1)[1].split('\031',1)[0].split('|')[id_counter].split(',') + prev_id = l.split("\t")[0] + + assigned_pair = l.split("\t")[1:8] + [l.split("\t")[-1]] + simulated_pair = ( + l.split("SIMULATED:", 1)[1] + .split("\031", 1)[0] + .split("|")[id_counter] + .split(",") + ) print(assigned_pair) print(simulated_pair, prev_id) print() diff --git a/tests/test_restrict.py b/tests/test_restrict.py index eaae59ea..5f2a6a0e 100644 --- a/tests/test_restrict.py +++ b/tests/test_restrict.py @@ -8,6 +8,7 @@ testdir = os.path.dirname(os.path.realpath(__file__)) + def test_restrict(): """Restrict pairs file""" mock_pairs_path = os.path.join(testdir, "data", "mock.test-restr.pairs") @@ -36,12 +37,12 @@ def test_restrict(): assert any([l in l2 for l2 in output_header]) # check that the pairs got assigned properly - cols = [x for x in output_header if x.startswith('#columns')][0].split(' ')[1:] + cols = [x for x in output_header if x.startswith("#columns")][0].split(" ")[1:] - COL_RFRAG1_TRUE = cols.index('rfrag_test1') - COL_RFRAG2_TRUE = cols.index('rfrag_test2') - COL_RFRAG1_OUTPUT = cols.index('rfrag1') - COL_RFRAG2_OUTPUT = cols.index('rfrag2') + COL_RFRAG1_TRUE = cols.index("rfrag_test1") + COL_RFRAG2_TRUE = cols.index("rfrag_test2") + COL_RFRAG1_OUTPUT = cols.index("rfrag1") + COL_RFRAG2_OUTPUT = cols.index("rfrag2") for l in result.split("\n"): if l.startswith("#") or not l: diff --git a/tests/test_select.py b/tests/test_select.py index a514453b..24a2d040 100644 --- a/tests/test_select.py +++ b/tests/test_select.py @@ -5,172 +5,206 @@ from nose.tools import assert_raises testdir = os.path.dirname(os.path.realpath(__file__)) -mock_pairsam_path = os.path.join(testdir, 'data', 'mock.pairsam') -mock_chromsizes_path = os.path.join(testdir, 'data', 'mock.chrom.sizes') +mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") +mock_chromsizes_path = os.path.join(testdir, "data", "mock.chrom.sizes") def test_preserve(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - 'True', - mock_pairsam_path], - ).decode('ascii') + ["python", "-m", "pairtools", "select", "True", mock_pairsam_path], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] assert all(l in pairsam_body for l in output_body) def test_equal(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - '(pair_type == "RU") or (pair_type == "UR") or (pair_type == "UU")', - mock_pairsam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "select", + '(pair_type == "RU") or (pair_type == "UR") or (pair_type == "UU")', + mock_pairsam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e print(result) - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] - assert all(l.split('\t')[7] in ['RU', 'UR', 'UU'] for l in output_body) - assert all(l in output_body - for l in pairsam_body - if l.split('\t')[7] in ['RU', 'UR', 'UU']) + assert all(l.split("\t")[7] in ["RU", "UR", "UU"] for l in output_body) + assert all( + l in output_body for l in pairsam_body if l.split("\t")[7] in ["RU", "UR", "UU"] + ) def test_csv(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - 'csv_match(pair_type, "RU,UR,UU")', - mock_pairsam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "select", + 'csv_match(pair_type, "RU,UR,UU")', + mock_pairsam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e print(result) - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] - assert all(l.split('\t')[7] in ['RU','UR', 'UU'] for l in output_body) - assert all(l in output_body - for l in pairsam_body - if l.split('\t')[7] in ['RU', 'UR', 'UU']) + assert all(l.split("\t")[7] in ["RU", "UR", "UU"] for l in output_body) + assert all( + l in output_body for l in pairsam_body if l.split("\t")[7] in ["RU", "UR", "UU"] + ) def test_wildcard(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - 'wildcard_match(pair_type, "*U")', - mock_pairsam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "select", + 'wildcard_match(pair_type, "*U")', + mock_pairsam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e print(result) - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] - assert all(l.split('\t')[7] in ['NU', 'MU', 'RU', 'UU'] for l in output_body) - assert all(l in output_body - for l in pairsam_body - if l.split('\t')[7] in ['NU', 'MU', 'RU', 'UU']) + assert all(l.split("\t")[7] in ["NU", "MU", "RU", "UU"] for l in output_body) + assert all( + l in output_body + for l in pairsam_body + if l.split("\t")[7] in ["NU", "MU", "RU", "UU"] + ) def test_regex(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - 'regex_match(pair_type, "[NM]U")', - mock_pairsam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "select", + 'regex_match(pair_type, "[NM]U")', + mock_pairsam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e print(result) - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] + + assert all(l.split("\t")[7] in ["NU", "MU"] for l in output_body) + assert all( + l in output_body for l in pairsam_body if l.split("\t")[7] in ["NU", "MU"] + ) + - assert all(l.split('\t')[7] in ['NU', 'MU'] for l in output_body) - assert all(l in output_body - for l in pairsam_body - if l.split('\t')[7] in ['NU', 'MU']) - def test_chrom_subset(): try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'select', - 'True', - '--chrom-subset', - mock_chromsizes_path, - mock_pairsam_path], - ).decode('ascii') + [ + "python", + "-m", + "pairtools", + "select", + "True", + "--chrom-subset", + mock_chromsizes_path, + mock_pairsam_path, + ], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] - output_header = [l.strip() for l in result.split('\n') - if l.startswith('#') and l.strip()] - - chroms_from_chrom_field = [l.strip().split()[1:] - for l in result.split('\n') - if l.startswith('#chromosomes:')][0] - - assert set(chroms_from_chrom_field) == set(['chr1', 'chr2']) - - chroms_from_chrom_sizes = [l.strip().split()[1] - for l in result.split('\n') - if l.startswith('#chromsize:')] - - assert set(chroms_from_chrom_sizes) == set(['chr1', 'chr2']) + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] + output_header = [ + l.strip() for l in result.split("\n") if l.startswith("#") and l.strip() + ] + + chroms_from_chrom_field = [ + l.strip().split()[1:] + for l in result.split("\n") + if l.startswith("#chromosomes:") + ][0] + + assert set(chroms_from_chrom_field) == set(["chr1", "chr2"]) + + chroms_from_chrom_sizes = [ + l.strip().split()[1] for l in result.split("\n") if l.startswith("#chromsize:") + ] + + assert set(chroms_from_chrom_sizes) == set(["chr1", "chr2"]) diff --git a/tests/test_sort.py b/tests/test_sort.py index f3a0fb6d..8c740dce 100644 --- a/tests/test_sort.py +++ b/tests/test_sort.py @@ -6,41 +6,43 @@ testdir = os.path.dirname(os.path.realpath(__file__)) + def test_mock_pairsam(): - mock_pairsam_path = os.path.join(testdir, 'data', 'mock.pairsam') + mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'sort', - mock_pairsam_path], - ).decode('ascii') + ["python", "-m", "pairtools", "sort", mock_pairsam_path], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - # Check that the only changes strings are a @PG record of a SAM header, # the "#sorted" entry and chromosomes - pairsam_header = [l.strip() for l in open(mock_pairsam_path, 'r') if l.startswith('#')] - output_header = [l.strip() for l in result.split('\n') if l.startswith('#')] + pairsam_header = [ + l.strip() for l in open(mock_pairsam_path, "r") if l.startswith("#") + ] + output_header = [l.strip() for l in result.split("\n") if l.startswith("#")] print(output_header) print(pairsam_header) for l in output_header: if not any([l in l2 for l2 in pairsam_header]): assert ( - l.startswith('#samheader: @PG') - or l.startswith('#sorted') - or l.startswith('#chromosomes') - ) - - pairsam_body = [l.strip() for l in open(mock_pairsam_path, 'r') - if not l.startswith('#') and l.strip()] - output_body = [l.strip() for l in result.split('\n') - if not l.startswith('#') and l.strip()] + l.startswith("#samheader: @PG") + or l.startswith("#sorted") + or l.startswith("#chromosomes") + ) + + pairsam_body = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if not l.startswith("#") and l.strip() + ] + output_body = [ + l.strip() for l in result.split("\n") if not l.startswith("#") and l.strip() + ] # check that all pairsam entries survived sorting: assert len(pairsam_body) == len(output_body) @@ -48,16 +50,14 @@ def test_mock_pairsam(): # check the sorting order of the output: prev_pair = None for l in output_body: - cur_pair = l.split('\t')[1:8] + cur_pair = l.split("\t")[1:8] if prev_pair is not None: - assert (cur_pair[0] >= prev_pair[0]) - if (cur_pair[0] == prev_pair[0]): - assert (cur_pair[2] >= prev_pair[2]) - if (cur_pair[2] == prev_pair[2]): - assert (cur_pair[1] >= prev_pair[1]) - if (cur_pair[1] == prev_pair[1]): - assert (cur_pair[3] >= prev_pair[3]) + assert cur_pair[0] >= prev_pair[0] + if cur_pair[0] == prev_pair[0]: + assert cur_pair[2] >= prev_pair[2] + if cur_pair[2] == prev_pair[2]: + assert cur_pair[1] >= prev_pair[1] + if cur_pair[1] == prev_pair[1]: + assert cur_pair[3] >= prev_pair[3] prev_pair = cur_pair - - diff --git a/tests/test_split.py b/tests/test_split.py index c99c5d72..5ce38998 100644 --- a/tests/test_split.py +++ b/tests/test_split.py @@ -6,75 +6,84 @@ import tempfile testdir = os.path.dirname(os.path.realpath(__file__)) -mock_pairsam_path = os.path.join(testdir, 'data', 'mock.pairsam') +mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") tmpdir = tempfile.TemporaryDirectory() tmpdir_name = tmpdir.name -pairs_path = os.path.join(tmpdir_name, 'out.pairs') -sam_path = os.path.join(tmpdir_name, 'out.sam') +pairs_path = os.path.join(tmpdir_name, "out.pairs") +sam_path = os.path.join(tmpdir_name, "out.sam") + def setup_func(): try: subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'split', - mock_pairsam_path, - '--output-pairs', - pairs_path, - '--output-sam', - sam_path, - ], - ) + [ + "python", + "-m", + "pairtools", + "split", + mock_pairsam_path, + "--output-pairs", + pairs_path, + "--output-sam", + sam_path, + ], + ) except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e + def teardown_func(): tmpdir.cleanup() + @with_setup(setup_func, teardown_func) def test_split(): - pairsam_lines = [l.strip() for l in open(mock_pairsam_path, 'r') - if l.strip()] - pairs_lines = [l.strip() for l in open(pairs_path, 'r') - if l.strip()] - sam_lines = [l.strip() for l in open(sam_path, 'r') - if l.strip()] + pairsam_lines = [l.strip() for l in open(mock_pairsam_path, "r") if l.strip()] + pairs_lines = [l.strip() for l in open(pairs_path, "r") if l.strip()] + sam_lines = [l.strip() for l in open(sam_path, "r") if l.strip()] # check that all entries survived splitting: - n_pairsam = len([l for l in pairsam_lines if not l.startswith('#')]) - n_pairs = len([l for l in pairs_lines if not l.startswith('#')]) - n_sam = len([l for l in sam_lines if not l.startswith('@')]) // 2 + n_pairsam = len([l for l in pairsam_lines if not l.startswith("#")]) + n_pairs = len([l for l in pairs_lines if not l.startswith("#")]) + n_sam = len([l for l in sam_lines if not l.startswith("@")]) // 2 assert n_pairsam == n_pairs assert n_pairsam == n_sam # check that the header survived splitting: - pairsam_header = [l.strip() for l in open(mock_pairsam_path, 'r') - if l.strip() and l.startswith('#')] - pairs_header = [l.strip() for l in open(pairs_path, 'r') - if l.strip() and l.startswith('#')] - sam_header = [l.strip() for l in open(sam_path, 'r') - if l.strip() and l.startswith('@')] + pairsam_header = [ + l.strip() + for l in open(mock_pairsam_path, "r") + if l.strip() and l.startswith("#") + ] + pairs_header = [ + l.strip() for l in open(pairs_path, "r") if l.strip() and l.startswith("#") + ] + sam_header = [ + l.strip() for l in open(sam_path, "r") if l.strip() and l.startswith("@") + ] assert all( - any(l in l2 for l2 in pairsam_header) - for l in sam_header if not l.startswith('@PG')) + any(l in l2 for l2 in pairsam_header) + for l in sam_header + if not l.startswith("@PG") + ) assert all( - l in pairsam_header - for l in pairs_header - if (not (l.startswith('#columns') or l.startswith('#samheader')))) - columns_pairsam = [l for l in pairsam_header if l.startswith('#columns')][0].split()[1:] - columns_pairs = [l for l in pairs_header if l.startswith('#columns')][0].split()[1:] + l in pairsam_header + for l in pairs_header + if (not (l.startswith("#columns") or l.startswith("#samheader"))) + ) + columns_pairsam = [l for l in pairsam_header if l.startswith("#columns")][ + 0 + ].split()[1:] + columns_pairs = [l for l in pairs_header if l.startswith("#columns")][0].split()[1:] assert ( - ('sam1' in columns_pairsam) - and ('sam2' in columns_pairsam) - and ('sam1' not in columns_pairs) - and ('sam2' not in columns_pairs)) - assert [c for c in columns_pairsam - if c != 'sam1' and c != 'sam2'] == columns_pairs - - + ("sam1" in columns_pairsam) + and ("sam2" in columns_pairsam) + and ("sam1" not in columns_pairs) + and ("sam2" not in columns_pairs) + ) + assert [c for c in columns_pairsam if c != "sam1" and c != "sam2"] == columns_pairs diff --git a/tests/test_stats.py b/tests/test_stats.py index a9a10674..344ef56f 100644 --- a/tests/test_stats.py +++ b/tests/test_stats.py @@ -6,51 +6,48 @@ testdir = os.path.dirname(os.path.realpath(__file__)) + def test_mock_pairsam(): - mock_pairsam_path = os.path.join(testdir, 'data', 'mock.pairsam') + mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") try: result = subprocess.check_output( - ['python', - '-m', - 'pairtools', - 'stats', - mock_pairsam_path], - ).decode('ascii') + ["python", "-m", "pairtools", "stats", mock_pairsam_path], + ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - - stats = dict(l.strip().split('\t') - for l in result.split('\n') - if not l.startswith('#') and l.strip()) + stats = dict( + l.strip().split("\t") + for l in result.split("\n") + if not l.startswith("#") and l.strip() + ) for k in stats: stats[k] = int(stats[k]) print(stats) - assert stats['total'] == 8 - assert stats['total_single_sided_mapped'] == 2 - assert stats['total_mapped'] == 5 - assert stats['cis'] == 3 - assert stats['trans'] == 2 - assert stats['pair_types/UU'] == 4 - assert stats['pair_types/NU'] == 1 - assert stats['pair_types/WW'] == 1 - assert stats['pair_types/UR'] == 1 - assert stats['pair_types/MU'] == 1 - assert stats['chrom_freq/chr1/chr2'] == 1 - assert stats['chrom_freq/chr1/chr1'] == 3 - assert stats['chrom_freq/chr2/chr3'] == 1 - assert all(stats[k]==0 - for k in stats - if k.startswith('dist_freq') - and k not in ['dist_freq/1-2/++', - 'dist_freq/2-3/++', - 'dist_freq/32-56/++']) - - assert stats['dist_freq/1-2/++'] == 1 - assert stats['dist_freq/2-3/++'] == 1 - assert stats['dist_freq/32-56/++'] == 1 + assert stats["total"] == 8 + assert stats["total_single_sided_mapped"] == 2 + assert stats["total_mapped"] == 5 + assert stats["cis"] == 3 + assert stats["trans"] == 2 + assert stats["pair_types/UU"] == 4 + assert stats["pair_types/NU"] == 1 + assert stats["pair_types/WW"] == 1 + assert stats["pair_types/UR"] == 1 + assert stats["pair_types/MU"] == 1 + assert stats["chrom_freq/chr1/chr2"] == 1 + assert stats["chrom_freq/chr1/chr1"] == 3 + assert stats["chrom_freq/chr2/chr3"] == 1 + assert all( + stats[k] == 0 + for k in stats + if k.startswith("dist_freq") + and k not in ["dist_freq/1-2/++", "dist_freq/2-3/++", "dist_freq/32-56/++"] + ) + assert stats["dist_freq/1-2/++"] == 1 + assert stats["dist_freq/2-3/++"] == 1 + assert stats["dist_freq/32-56/++"] == 1 From 5d5a5bc32f38c714cf3d0f6cc2a5f1a5a319fcee Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 12 Apr 2022 08:08:02 -0400 Subject: [PATCH 08/52] separate cli and lib --- pairtools/__init__.py | 120 +--- pairtools/__main__.py | 4 +- pairtools/cli/__init__.py | 118 ++++ pairtools/cli/dedup.py | 485 ++++++++++++++ pairtools/cli/filterbycov.py | 371 +++++++++++ pairtools/{pairtools_flip.py => cli/flip.py} | 23 +- pairtools/cli/markasdup.py | 71 ++ .../{pairtools_merge.py => cli/merge.py} | 29 +- .../{pairtools_parse.py => cli/parse.py} | 35 +- .../{pairtools_parse2.py => cli/parse2.py} | 36 +- .../{pairtools_phase.py => cli/phase.py} | 51 +- .../restrict.py} | 53 +- .../{pairtools_sample.py => cli/sample.py} | 11 +- .../{pairtools_select.py => cli/select.py} | 21 +- pairtools/{pairtools_sort.py => cli/sort.py} | 25 +- .../{pairtools_split.py => cli/split.py} | 27 +- pairtools/cli/stats.py | 81 +++ pairtools/lib/__init__.py | 11 + .../{pairtools_dedup.py => lib/dedup.py} | 492 +------------- .../{_dedup.pyx => lib/dedup_cython.pyx} | 116 ---- pairtools/{_fileio.py => lib/fileio.py} | 0 pairtools/lib/filterbycov.py | 256 ++++++++ pairtools/{_headerops.py => lib/headerops.py} | 7 +- pairtools/lib/markasdup.py | 40 ++ .../pairsam_format.py} | 0 pairtools/{_parse.py => lib/parse.py} | 53 +- .../{_parse_pysam.pyx => lib/parse_pysam.pyx} | 0 pairtools/lib/restrict.py | 29 + .../{pairtools_stats.py => lib/stats.py} | 98 +-- pairtools/pairtools_filterbycov.py | 621 ------------------ pairtools/pairtools_markasdup.py | 109 --- setup.py | 11 +- tests/test_headerops.py | 30 +- 33 files changed, 1676 insertions(+), 1758 deletions(-) create mode 100644 pairtools/cli/__init__.py create mode 100644 pairtools/cli/dedup.py create mode 100644 pairtools/cli/filterbycov.py rename pairtools/{pairtools_flip.py => cli/flip.py} (86%) create mode 100644 pairtools/cli/markasdup.py rename pairtools/{pairtools_merge.py => cli/merge.py} (91%) rename pairtools/{pairtools_parse.py => cli/parse.py} (91%) rename pairtools/{pairtools_parse2.py => cli/parse2.py} (91%) rename pairtools/{pairtools_phase.py => cli/phase.py} (74%) rename pairtools/{pairtools_restrict.py => cli/restrict.py} (65%) rename pairtools/{pairtools_sample.py => cli/sample.py} (85%) rename pairtools/{pairtools_select.py => cli/select.py} (92%) rename pairtools/{pairtools_sort.py => cli/sort.py} (87%) rename pairtools/{pairtools_split.py => cli/split.py} (84%) create mode 100644 pairtools/cli/stats.py create mode 100644 pairtools/lib/__init__.py rename pairtools/{pairtools_dedup.py => lib/dedup.py} (54%) rename pairtools/{_dedup.pyx => lib/dedup_cython.pyx} (63%) rename pairtools/{_fileio.py => lib/fileio.py} (100%) create mode 100644 pairtools/lib/filterbycov.py rename pairtools/{_headerops.py => lib/headerops.py} (99%) create mode 100644 pairtools/lib/markasdup.py rename pairtools/{_pairsam_format.py => lib/pairsam_format.py} (100%) rename pairtools/{_parse.py => lib/parse.py} (97%) rename pairtools/{_parse_pysam.pyx => lib/parse_pysam.pyx} (100%) create mode 100644 pairtools/lib/restrict.py rename pairtools/{pairtools_stats.py => lib/stats.py} (89%) mode change 100755 => 100644 delete mode 100644 pairtools/pairtools_filterbycov.py delete mode 100644 pairtools/pairtools_markasdup.py diff --git a/pairtools/__init__.py b/pairtools/__init__.py index 281a75a2..c534813d 100644 --- a/pairtools/__init__.py +++ b/pairtools/__init__.py @@ -1,129 +1,15 @@ -# -*- coding: utf-8 -*- """ pairtools ~~~~~~~~~ CLI tools to process mapped Hi-C data -:copyright: (c) 2017-2021 Open2C +:copyright: (c) 2017-2022 Open2C :author: Open2C :license: MIT """ -__version__ = "0.3.1-dev.1" +__version__ = "1.0.0-dev1" - -import click -import functools -import sys - -CONTEXT_SETTINGS = { - "help_option_names": ["-h", "--help"], -} - - -@click.version_option(version=__version__) -@click.group(context_settings=CONTEXT_SETTINGS) -@click.option( - "--post-mortem", help="Post mortem debugging", is_flag=True, default=False -) -@click.option( - "--output-profile", - help="Profile performance with Python cProfile and dump the statistics " - "into a binary file", - type=str, - default="", -) -def cli(post_mortem, output_profile): - """Flexible tools for Hi-C data processing. - - All pairtools have a few common options, which should be typed _before_ - the command name. - - """ - if post_mortem: - import traceback - - try: - import ipdb as pdb - except ImportError: - import pdb - - def _excepthook(exc_type, value, tb): - traceback.print_exception(exc_type, value, tb) - print() - pdb.pm() - - sys.excepthook = _excepthook - - if output_profile: - import cProfile - import atexit - - pr = cProfile.Profile() - pr.enable() - - def _atexit_profile_hook(): - pr.disable() - pr.dump_stats(output_profile) - - atexit.register(_atexit_profile_hook) - - -def common_io_options(func): - @click.option( - "--nproc-in", - type=int, - default=3, - show_default=True, - help="Number of processes used by the auto-guessed input decompressing command.", - ) - @click.option( - "--nproc-out", - type=int, - default=8, - show_default=True, - help="Number of processes used by the auto-guessed output compressing command.", - ) - @click.option( - "--cmd-in", - type=str, - default=None, - help="A command to decompress the input file. " - "If provided, fully overrides the auto-guessed command. " - "Does not work with stdin and pairtools parse. " - "Must read input from stdin and print output into stdout. " - "EXAMPLE: pbgzip -dc -n 3", - ) - @click.option( - "--cmd-out", - type=str, - default=None, - help="A command to compress the output file. " - "If provided, fully overrides the auto-guessed command. " - "Does not work with stdout. " - "Must read input from stdin and print output into stdout. " - "EXAMPLE: pbgzip -c -n 8", - ) - @functools.wraps(func) - def wrapper(*args, **kwargs): - return func(*args, **kwargs) - - return wrapper - - -from .pairtools_dedup import dedup -from .pairtools_sort import sort -from .pairtools_flip import flip -from .pairtools_merge import merge -from .pairtools_markasdup import markasdup -from .pairtools_select import select -from .pairtools_split import split -from .pairtools_restrict import restrict -from .pairtools_phase import phase -from .pairtools_parse import parse -from .pairtools_parse2 import parse2 -from .pairtools_stats import stats -from .pairtools_sample import sample -from .pairtools_filterbycov import filterbycov +# from . import lib \ No newline at end of file diff --git a/pairtools/__main__.py b/pairtools/__main__.py index 7c4a768c..7e34ccd6 100644 --- a/pairtools/__main__.py +++ b/pairtools/__main__.py @@ -1,4 +1,4 @@ -from . import cli +from .cli import cli if __name__ == "__main__": - cli() + cli() \ No newline at end of file diff --git a/pairtools/cli/__init__.py b/pairtools/cli/__init__.py new file mode 100644 index 00000000..566ae0c0 --- /dev/null +++ b/pairtools/cli/__init__.py @@ -0,0 +1,118 @@ +# -*- coding: utf-8 -*- + +import click +import functools +import sys +from .. import __version__ + +CONTEXT_SETTINGS = { + "help_option_names": ["-h", "--help"], +} + + +@click.version_option(version=__version__) +@click.group(context_settings=CONTEXT_SETTINGS) +@click.option( + "--post-mortem", help="Post mortem debugging", is_flag=True, default=False +) +@click.option( + "--output-profile", + help="Profile performance with Python cProfile and dump the statistics " + "into a binary file", + type=str, + default="", +) +def cli(post_mortem, output_profile): + """Flexible tools for Hi-C data processing. + + All pairtools have a few common options, which should be typed _before_ + the command name. + + """ + if post_mortem: + import traceback + + try: + import ipdb as pdb + except ImportError: + import pdb + + def _excepthook(exc_type, value, tb): + traceback.print_exception(exc_type, value, tb) + print() + pdb.pm() + + sys.excepthook = _excepthook + + if output_profile: + import cProfile + import atexit + + pr = cProfile.Profile() + pr.enable() + + def _atexit_profile_hook(): + pr.disable() + pr.dump_stats(output_profile) + + atexit.register(_atexit_profile_hook) + + +def common_io_options(func): + @click.option( + "--nproc-in", + type=int, + default=3, + show_default=True, + help="Number of processes used by the auto-guessed input decompressing command.", + ) + @click.option( + "--nproc-out", + type=int, + default=8, + show_default=True, + help="Number of processes used by the auto-guessed output compressing command.", + ) + @click.option( + "--cmd-in", + type=str, + default=None, + help="A command to decompress the input file. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdin and pairtools parse. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -dc -n 3", + ) + @click.option( + "--cmd-out", + type=str, + default=None, + help="A command to compress the output file. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdout. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -c -n 8", + ) + @functools.wraps(func) + def wrapper(*args, **kwargs): + return func(*args, **kwargs) + + return wrapper + + +from . import ( + dedup, + sort, + flip, + merge, + markasdup, + select, + split, + restrict, + phase, + parse, + parse2, + stats, + sample, + filterbycov, +) diff --git a/pairtools/cli/dedup.py b/pairtools/cli/dedup.py new file mode 100644 index 00000000..55a3348c --- /dev/null +++ b/pairtools/cli/dedup.py @@ -0,0 +1,485 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import sys +import ast +import pathlib + +# from distutils.log import warn +# import warnings + +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +import click + +from ..lib.dedup import streaming_dedup, streaming_dedup_cython +from ..lib.stats import PairCounter + +UTIL_NAME = "pairtools_dedup" + + +@cli.command() +@click.argument("pairs_path", type=str, required=False) + +### Output files: +@click.option( + "-o", + "--output", + type=str, + default="", + help="output file for pairs after duplicate removal." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) +@click.option( + "--output-dups", + type=str, + default="", + help="output file for duplicated pairs. " + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " If the path is the same as in --output or -, output duplicates together " + " with deduped pairs. By default, duplicates are dropped.", +) +@click.option( + "--output-unmapped", + type=str, + default="", + help="output file for unmapped pairs. " + "If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. " + "If the path is the same as in --output or -, output unmapped pairs together " + "with deduped pairs. If the path is the same as --output-dups, output " + "unmapped reads together with dups. By default, unmapped pairs are dropped.", +) +@click.option( + "--output-stats", + type=str, + default="", + help="output file for duplicate statistics." + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, statistics are not printed.", +) + +### Set the dedup method: +@click.option( + "--max-mismatch", + type=int, + default=3, + show_default=True, + help="Pairs with both sides mapped within this distance (bp) from each " + "other are considered duplicates. ", +) +@click.option( + "--method", + type=click.Choice(["max", "sum"]), + default="max", + help="define the mismatch as either the max or the sum of the mismatches of" + "the genomic locations of the both sides of the two compared molecules", + show_default=True, +) +@click.option( + "--backend", + type=click.Choice(["scipy", "sklearn", "cython"]), + default="scipy", + help="What backend to use: scipy and sklearn are based on KD-trees," + " cython is online indexed list-based algorithm." + " With cython backend, duplication is not transitive with non-zero max mismatch " + " (e.g. pairs A and B are duplicates, and B and C are duplicates, then A and C are " + " not necessary duplicates of each other), while with scipy and sklearn it's " + " transitive (i.e. A and C are necessarily duplicates)." + " Cython is the original version used in pairtools since its beginning." + " It is available for backwards compatibility and to allow specification of the" + " column order." + " Now the default scipy backend is generally the fastest, and with chunksize below" + " 1 mln has the lowest memory requirements." + # " 'cython' is deprecated and provided for backwards compatibility", +) + +### Scipy and sklearn-specific options: +@click.option( + "--chunksize", + type=int, + default=100_000, + show_default=True, + help="Number of pairs in each chunk. Reduce for lower memory footprint." + " Below 10,000 performance starts suffering significantly and the algorithm might" + " miss a few duplicates with non-zero --max-mismatch." + " Only works with '--backend scipy or sklearn'", +) +@click.option( + "--carryover", + type=int, + default=100, + show_default=True, + help="Number of deduped pairs to carry over from previous chunk to the new chunk" + " to avoid breaking duplicate clusters." + " Only works with '--backend scipy or sklearn'", +) +@click.option( + "-p", + "--n-proc", + type=int, + default=1, + help="Number of cores to use. Only applies with sklearn backend." + "Still needs testing whether it is ever useful.", +) + +### Output options: +@click.option( + "--mark-dups", + is_flag=True, + help='If specified, duplicate pairs are marked as DD in "pair_type" and ' + "as a duplicate in the sam entries.", +) +@click.option( + "--keep-parent-id", + is_flag=True, + help="If specified, duplicate pairs are marked with the readID of the retained" + " deduped read in the 'parent_readID' field.", +) +@click.option( + "--extra-col-pair", + nargs=2, + # type=click.Tuple([str, str]), + multiple=True, + help="Extra columns that also must match for two pairs to be marked as " + "duplicates. Can be either provided as 0-based column indices or as column " + 'names (requires the "#columns" header field). The option can be provided ' + "multiple times if multiple column pairs must match. " + 'Example: --extra-col-pair "phase1" "phase2"', +) + +### Input options: +@click.option( + "--sep", + type=str, + default=pairsam_format.PAIRSAM_SEP_ESCAPE, + help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", +) +@click.option( + "--comment-char", type=str, default="#", help="The first character of comment lines" +) +@click.option( + "--send-header-to", + type=click.Choice(["dups", "dedup", "both", "none"]), + default="both", + help="Which of the outputs should receive header and comment lines", +) +@click.option( + "--c1", + type=int, + default=pairsam_format.COL_C1, + help=f"Chrom 1 column; default {pairsam_format.COL_C1}" + " Only works with '--backend cython'", +) +@click.option( + "--c2", + type=int, + default=pairsam_format.COL_C2, + help=f"Chrom 2 column; default {pairsam_format.COL_C2}" + " Only works with '--backend cython'", +) +@click.option( + "--p1", + type=int, + default=pairsam_format.COL_P1, + help=f"Position 1 column; default {pairsam_format.COL_P1}" + " Only works with '--backend cython'", +) +@click.option( + "--p2", + type=int, + default=pairsam_format.COL_P2, + help=f"Position 2 column; default {pairsam_format.COL_P2}" + " Only works with '--backend cython'", +) +@click.option( + "--s1", + type=int, + default=pairsam_format.COL_S1, + help=f"Strand 1 column; default {pairsam_format.COL_S1}" + " Only works with '--backend cython'", +) +@click.option( + "--s2", + type=int, + default=pairsam_format.COL_S2, + help=f"Strand 2 column; default {pairsam_format.COL_S2}" + " Only works with '--backend cython'", +) +@click.option( + "--unmapped-chrom", + type=str, + default=pairsam_format.UNMAPPED_CHROM, + help="Placeholder for a chromosome on an unmapped side; default {}".format( + pairsam_format.UNMAPPED_CHROM + ), +) +@common_io_options +def dedup( + pairs_path, + output, + output_dups, + output_unmapped, + output_stats, + chunksize, + carryover, + max_mismatch, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_dups, + extra_col_pair, + keep_parent_id, + backend, + n_proc, + **kwargs, +): + """Find and remove PCR/optical duplicates. + + Find PCR duplicates in an upper-triangular flipped sorted pairs/pairsam + file. Allow for a +/-N bp mismatch at each side of duplicated molecules. + + PAIRS_PATH : input triu-flipped sorted .pairs or .pairsam file. If the + path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. + By default, the input is read from stdin. + """ + + dedup_py( + pairs_path, + output, + output_dups, + output_unmapped, + output_stats, + chunksize, + carryover, + max_mismatch, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_dups, + extra_col_pair, + keep_parent_id, + backend, + n_proc, + **kwargs, + ) + + +if __name__ == "__main__": + dedup() + + +def dedup_py( + pairs_path, + output, + output_dups, + output_unmapped, + output_stats, + chunksize, + carryover, + max_mismatch, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_dups, + extra_col_pair, + keep_parent_id, + backend, + n_proc, + **kwargs, +): + + sep = ast.literal_eval('"""' + sep + '"""') + send_header_to_dedup = send_header_to in ["both", "dedup"] + send_header_to_dup = send_header_to in ["both", "dups"] + + instream = ( + fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + out_stats_stream = ( + fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output_stats + else None + ) + + # generate empty PairCounter if stats output is requested: + out_stat = PairCounter() if output_stats else None + + if not output_dups: + outstream_dups = None + elif output_dups == "-" or ( + pathlib.Path(output_dups).absolute() == pathlib.Path(output).absolute() + ): + outstream_dups = outstream + else: + outstream_dups = fileio.auto_open( + output_dups, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + if not output_unmapped: + outstream_unmapped = None + elif output_unmapped == "-" or ( + pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute() + ): + outstream_unmapped = outstream + elif ( + pathlib.Path(output_unmapped).absolute() == pathlib.Path(output_dups).absolute() + ): + outstream_unmapped = outstream_dups + else: + outstream_unmapped = fileio.auto_open( + output_unmapped, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + if send_header_to_dedup: + outstream.writelines((l + "\n" for l in header)) + if send_header_to_dup and outstream_dups and (outstream_dups != outstream): + dups_header = header + if keep_parent_id and len(dups_header) > 0: + dups_header = headerops.append_columns(dups_header, ["parent_readID"]) + outstream_dups.writelines((l + "\n" for l in dups_header)) + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_dups) + ): + outstream_unmapped.writelines((l + "\n" for l in header)) + + column_names = headerops.extract_column_names(header) + extra_cols1 = [] + extra_cols2 = [] + if extra_col_pair is not None: + for col1, col2 in extra_col_pair: + extra_cols1.append(column_names[col1] if col1.isdigit() else col1) + extra_cols2.append(column_names[col2] if col2.isdigit() else col2) + + if backend == "cython": + # warnings.warn( + # "'cython' backend is deprecated and provided only" + # " for backwards compatibility", + # DeprecationWarning, + # ) + extra_cols1 = [column_names.index(col) for col in extra_cols1] + extra_cols2 = [column_names.index(col) for col in extra_cols2] + streaming_dedup_cython( + method, + max_mismatch, + sep, + c1, + c2, + p1, + p2, + s1, + s2, + extra_cols1, + extra_cols2, + unmapped_chrom, + body_stream, + outstream, + outstream_dups, + outstream_unmapped, + out_stat, + mark_dups, + keep_parent_id, + ) + elif backend in ("scipy", "sklearn"): + streaming_dedup( + in_stream=instream, + colnames=column_names, + chunksize=chunksize, + carryover=carryover, + method=method, + mark_dups=mark_dups, + max_mismatch=max_mismatch, + extra_col_pairs=list(extra_col_pair), + keep_parent_id=keep_parent_id, + unmapped_chrom=unmapped_chrom, + comment_char=comment_char, + outstream=outstream, + outstream_dups=outstream_dups, + outstream_unmapped=outstream_unmapped, + out_stat=out_stat, + backend=backend, + n_proc=n_proc, + ) + else: + raise ValueError("Unknown backend") + + # save statistics to a file if it was requested: + if out_stat: + out_stat.save(out_stats_stream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + if outstream_dups and (outstream_dups != outstream): + outstream_dups.close() + + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_dups) + ): + outstream_unmapped.close() + + if out_stats_stream: + out_stats_stream.close() diff --git a/pairtools/cli/filterbycov.py b/pairtools/cli/filterbycov.py new file mode 100644 index 00000000..d95294ba --- /dev/null +++ b/pairtools/cli/filterbycov.py @@ -0,0 +1,371 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys +import ast +import warnings +import pathlib + +import click + +from ..lib import fileio, pairsam_format, headerops, dedup +from . import cli, common_io_options + +from ..lib.filterbycov import streaming_filterbycov +from ..lib.stats import PairCounter + + +UTIL_NAME = "pairtools_filterbycov" + +###################################### +## TODO: - output stats after filtering +## edit/update mark as dup to mark as multi +################################### + + +@cli.command() +@click.argument("pairs_path", type=str, required=False) +@click.option( + "-o", + "--output", + type=str, + default="", + help="output file for pairs from low coverage regions." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) +@click.option( + "--output-highcov", + type=str, + default="", + help="output file for pairs from high coverage regions." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " If the path is the same as in --output or -, output duplicates together " + " with deduped pairs. By default, duplicates are dropped.", +) +@click.option( + "--output-unmapped", + type=str, + default="", + help="output file for unmapped pairs. " + "If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. " + "If the path is the same as in --output or -, output unmapped pairs together " + "with deduped pairs. If the path is the same as --output-highcov, " + "output unmapped reads together. By default, unmapped pairs are dropped.", +) +@click.option( + "--output-stats", + type=str, + default="", + help="output file for statistics of multiple interactors. " + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, statistics are not printed.", +) +@click.option( + "--max-cov", type=int, default=8, help="The maximum allowed coverage per region." +) +@click.option( + "--max-dist", + type=int, + default=500, + help="The resolution for calculating coverage. For each pair, the local " + "coverage around each end is calculated as (1 + the number of neighbouring " + "pairs within +/- max_dist bp) ", +) +@click.option( + "--method", + type=click.Choice(["max", "sum"]), + default="max", + help="calculate the number of neighbouring pairs as either the sum or the max" + " of the number of neighbours on the two sides", + show_default=True, +) +@click.option( + "--sep", + type=str, + default=pairsam_format.PAIRSAM_SEP_ESCAPE, + help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", +) +@click.option( + "--comment-char", type=str, default="#", help="The first character of comment lines" +) +@click.option( + "--send-header-to", + type=click.Choice(["lowcov", "highcov", "both", "none"]), + default="both", + help="Which of the outputs should receive header and comment lines", +) +@click.option( + "--c1", + type=int, + default=pairsam_format.COL_C1, + help="Chrom 1 column; default {}".format(pairsam_format.COL_C1), +) +@click.option( + "--c2", + type=int, + default=pairsam_format.COL_C2, + help="Chrom 2 column; default {}".format(pairsam_format.COL_C2), +) +@click.option( + "--p1", + type=int, + default=pairsam_format.COL_P1, + help="Position 1 column; default {}".format(pairsam_format.COL_P1), +) +@click.option( + "--p2", + type=int, + default=pairsam_format.COL_P2, + help="Position 2 column; default {}".format(pairsam_format.COL_P2), +) +@click.option( + "--s1", + type=int, + default=pairsam_format.COL_S1, + help="Strand 1 column; default {}".format(pairsam_format.COL_S1), +) +@click.option( + "--s2", + type=int, + default=pairsam_format.COL_S2, + help="Strand 2 column; default {}".format(pairsam_format.COL_S2), +) +@click.option( + "--unmapped-chrom", + type=str, + default=pairsam_format.UNMAPPED_CHROM, + help="Placeholder for a chromosome on an unmapped side; default {}".format( + pairsam_format.UNMAPPED_CHROM + ), +) +@click.option( + "--mark-multi", + is_flag=True, + help='If specified, duplicate pairs are marked as FF in "pair_type" and ' + "as a duplicate in the sam entries.", +) +@common_io_options +def filterbycov( + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, + **kwargs +): + """Remove pairs from regions of high coverage. + + Find and remove pairs with >(MAX_COV-1) neighbouring pairs + within a +/- MAX_DIST bp window around either side. Useful for single-cell + Hi-C experiments, where coverage is naturally limited by the chromosome + copy number. + + PAIRS_PATH : input triu-flipped sorted .pairs or .pairsam file. If the + path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. + By default, the input is read from stdin. + """ + filterbycov_py( + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, + **kwargs + ) + + +def filterbycov_py( + pairs_path, + output, + output_highcov, + output_unmapped, + output_stats, + max_dist, + max_cov, + method, + sep, + comment_char, + send_header_to, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + mark_multi, + **kwargs +): + + ## Prepare input, output streams based on selected outputs + ## Default ouput stream is low-frequency interactors + sep = ast.literal_eval('"""' + sep + '"""') + send_header_to_lowcov = send_header_to in ["both", "lowcov"] + send_header_to_highcov = send_header_to in ["both", "highcov"] + + instream = ( + fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + out_stats_stream = ( + fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output_stats + else None + ) + + # generate empty PairCounter if stats output is requested: + out_stat = PairCounter() if output_stats else None + + # output the high-frequency interacting pairs + if not output_highcov: + outstream_high = None + elif output_highcov == "-" or ( + pathlib.Path(output_highcov).absolute() == pathlib.Path(output).absolute() + ): + outstream_high = outstream + else: + outstream_high = fileio.auto_open( + output_highcov, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + # output unmapped pairs + if not output_unmapped: + outstream_unmapped = None + elif output_unmapped == "-" or ( + pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute() + ): + outstream_unmapped = outstream + elif ( + pathlib.Path(output_unmapped).absolute() + == pathlib.Path(output_highcov).absolute() + ): + outstream_unmapped = outstream_high + else: + outstream_unmapped = fileio.auto_open( + output_unmapped, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + # prepare file headers + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + + # header for low-frequency interactors + if send_header_to_lowcov: + outstream.writelines((l + "\n" for l in header)) + + # header for high-frequency interactors + if send_header_to_highcov and outstream_high and (outstream_high != outstream): + outstream_high.writelines((l + "\n" for l in header)) + + # header for unmapped pairs + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_high) + ): + outstream_unmapped.writelines((l + "\n" for l in header)) + + # perform filtering of pairs based on low/high-frequency of interaction + streaming_filterbycov( + method, + max_dist, + max_cov, + sep, + c1, + c2, + p1, + p2, + s1, + s2, + unmapped_chrom, + body_stream, + outstream, + outstream_high, + outstream_unmapped, + out_stat, + mark_multi, + ) + + ## FINISHED! + # save statistics to a file if it was requested: TO BE TESTED + if out_stat: + out_stat.save(out_stats_stream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + if outstream_high and (outstream_high != outstream): + outstream_high.close() + + if ( + outstream_unmapped + and (outstream_unmapped != outstream) + and (outstream_unmapped != outstream_high) + ): + outstream_unmapped.close() + + if out_stats_stream: + out_stats_stream.close() + + +if __name__ == "__main__": + filterbycov() diff --git a/pairtools/pairtools_flip.py b/pairtools/cli/flip.py similarity index 86% rename from pairtools/pairtools_flip.py rename to pairtools/cli/flip.py index 95bb1a83..abb0990a 100644 --- a/pairtools/pairtools_flip.py +++ b/pairtools/cli/flip.py @@ -1,7 +1,8 @@ import sys import click -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options import warnings UTIL_NAME = "pairtools_flip" @@ -49,7 +50,7 @@ def flip(pairs_path, chroms_path, output, **kwargs): def flip_py(pairs_path, chroms_path, output, **kwargs): instream = ( - _fileio.auto_open( + fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), @@ -59,7 +60,7 @@ def flip_py(pairs_path, chroms_path, output, **kwargs): else sys.stdin ) outstream = ( - _fileio.auto_open( + fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -69,21 +70,21 @@ def flip_py(pairs_path, chroms_path, output, **kwargs): else sys.stdout ) - chromosomes = _headerops.get_chrom_order(chroms_path) + chromosomes = headerops.get_chrom_order(chroms_path) chrom_enum = dict( zip( - [_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), + [pairsam_format.UNMAPPED_CHROM] + list(chromosomes), range(len(chromosomes) + 1), ) ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l + "\n" for l in header)) - column_names = _headerops.extract_column_names(header) + column_names = headerops.extract_column_names(header) if len(column_names) == 0: - column_names = _pairsam_format.COLUMNS + column_names = pairsam_format.COLUMNS chrom1_col = column_names.index("chrom1") chrom2_col = column_names.index("chrom2") @@ -100,7 +101,7 @@ def flip_py(pairs_path, chroms_path, output, **kwargs): ] for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) + cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) is_annotated1 = cols[chrom1_col] in chrom_enum.keys() is_annotated2 = cols[chrom2_col] in chrom_enum.keys() @@ -127,7 +128,7 @@ def flip_py(pairs_path, chroms_path, output, **kwargs): if pair_type_col != -1 and pair_type_col < len(cols): cols[pair_type_col] = cols[pair_type_col][1] + cols[pair_type_col][0] - outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) + outstream.write(pairsam_format.PAIRSAM_SEP.join(cols)) outstream.write("\n") if instream != sys.stdin: diff --git a/pairtools/cli/markasdup.py b/pairtools/cli/markasdup.py new file mode 100644 index 00000000..b0f1cea8 --- /dev/null +++ b/pairtools/cli/markasdup.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys +import click + +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.markasdup import mark_split_pair_as_dup + + +UTIL_NAME = "pairtools_markasdup" + + +@cli.command() +@click.argument("pairsam_path", type=str, required=False) +@click.option( + "-o", + "--output", + type=str, + default="", + help="output .pairsam file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) +@common_io_options +def markasdup(pairsam_path, output, **kwargs): + """Tag pairs as duplicates. + + Change the type of all pairs inside a .pairs/.pairsam file to DD. If sam + entries are present, change the pair type in the Yt SAM tag to 'Yt:Z:DD'. + + PAIRSAM_PATH : input .pairs/.pairsam file. If the path ends with .gz, the + input is gzip-decompressed. By default, the input is read from stdin. + """ + markasdup_py(pairsam_path, output, **kwargs) + + +def markasdup_py(pairsam_path, output, **kwargs): + instream = fileio.auto_open( + pairsam_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + outstream.writelines((l + "\n" for l in header)) + + for line in body_stream: + cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) + mark_split_pair_as_dup(cols) + + outstream.write(pairsam_format.PAIRSAM_SEP.join(cols)) + outstream.write("\n") + + if instream != sys.stdin: + instream.close() + if outstream != sys.stdout: + outstream.close() + + +if __name__ == "__main__": + markasdup() diff --git a/pairtools/pairtools_merge.py b/pairtools/cli/merge.py similarity index 91% rename from pairtools/pairtools_merge.py rename to pairtools/cli/merge.py index 588ebbc2..69eb22ec 100644 --- a/pairtools/pairtools_merge.py +++ b/pairtools/cli/merge.py @@ -5,7 +5,8 @@ import subprocess import click -from . import _fileio, _pairsam_format, _headerops, cli +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_merge" @@ -150,7 +151,7 @@ def merge_py( if len(paths) == 0: raise ValueError(f"No input paths: {pairs_path}") - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -159,7 +160,7 @@ def merge_py( # if there is only one input, bypass merging and do not modify the header if len(paths) == 1: - instream = _fileio.auto_open( + instream = fileio.auto_open( paths[0], mode="r", nproc=kwargs.get("nproc_in"), @@ -174,24 +175,24 @@ def merge_py( headers = [] for path in paths: - f = _fileio.auto_open( + f = fileio.auto_open( path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - h, _ = _headerops.get_header(f) + h, _ = headerops.get_header(f) headers.append(h) f.close() # Skip other headers if keep_first_header is True (False by default): if kwargs.get("keep_first_header", False): break - if not _headerops.all_same_columns(headers): + if not headerops.all_same_columns(headers): raise ValueError("Input pairs cannot contain different columns") - merged_header = _headerops.merge_headers(headers) - merged_header = _headerops.append_new_pg(merged_header, ID=UTIL_NAME, PN=UTIL_NAME) + merged_header = headerops.merge_headers(headers) + merged_header = headerops.append_new_pg(merged_header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l + "\n" for l in merged_header)) outstream.flush() @@ -215,12 +216,12 @@ def merge_py( """.replace( "\n", " " ).format( - _pairsam_format.COL_C1 + 1, - _pairsam_format.COL_C2 + 1, - _pairsam_format.COL_P1 + 1, - _pairsam_format.COL_P2 + 1, - _pairsam_format.COL_PTYPE + 1, - _pairsam_format.PAIRSAM_SEP_ESCAPE, + pairsam_format.COL_C1 + 1, + pairsam_format.COL_C2 + 1, + pairsam_format.COL_P1 + 1, + pairsam_format.COL_P2 + 1, + pairsam_format.COL_PTYPE + 1, + pairsam_format.PAIRSAM_SEP_ESCAPE, " --parallel={} ".format(nproc) if nproc > 1 else " ", " --batch-size={} ".format(max_nmerge) if max_nmerge else " ", " --temporary-directory={} ".format(tmpdir) if tmpdir else " ", diff --git a/pairtools/pairtools_parse.py b/pairtools/cli/parse.py similarity index 91% rename from pairtools/pairtools_parse.py rename to pairtools/cli/parse.py index b174f2e7..18052b3c 100644 --- a/pairtools/pairtools_parse.py +++ b/pairtools/cli/parse.py @@ -1,19 +1,14 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -import subprocess -import fileinput -import itertools import click -import pipes import sys -import os -import io -import pysam -from . import _fileio, _pairsam_format, _parse, _headerops, cli, common_io_options -from .pairtools_stats import PairCounter -from ._parse_pysam import AlignmentFilePairtoolized -from ._parse import streaming_classify +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.stats import PairCounter +from ..lib.parse_pysam import AlignmentFilePairtoolized +from ..lib.parse import streaming_classify UTIL_NAME = "pairtools_parse" @@ -197,7 +192,7 @@ def parse_py( input_sam = AlignmentFilePairtoolized("-", "r", threads=kwargs.get("nproc_in")) ### Set up output streams - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -206,14 +201,14 @@ def parse_py( out_alignments_stream, out_stats_stream = None, None if output_parsed_alignments: - out_alignments_stream = _fileio.auto_open( + out_alignments_stream = fileio.auto_open( output_parsed_alignments, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) if output_stats: - out_stats_stream = _fileio.auto_open( + out_stats_stream = fileio.auto_open( output_stats, mode="w", nproc=kwargs.get("nproc_out"), @@ -235,7 +230,7 @@ def parse_py( if not ((col in EXTRA_COLUMNS) or (len(col) == 2 and col.isupper())): raise Exception("{} is not a valid extra column".format(col)) - columns = _pairsam_format.COLUMNS + ( + columns = pairsam_format.COLUMNS + ( [c + side for c in add_columns for side in ["1", "2"]] ) @@ -255,19 +250,19 @@ def parse_py( ) ### Parse chromosome files present in the input - sam_chromsizes = _headerops.get_chromsizes_from_pysam_header(samheader) - chromosomes = _headerops.get_chrom_order(chroms_path, list(sam_chromsizes.keys())) + sam_chromsizes = headerops.get_chromsizes_from_pysam_header(samheader) + chromosomes = headerops.get_chrom_order(chroms_path, list(sam_chromsizes.keys())) ### Write new header to the pairsam file - header = _headerops.make_standard_pairsheader( + header = headerops.make_standard_pairsheader( assembly=kwargs.get("assembly", ""), chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], columns=columns, shape="whole matrix" if kwargs["no_flip"] else "upper triangle", ) - header = _headerops.insert_samheader_pysam(header, samheader) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header = headerops.insert_samheader_pysam(header, samheader) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l + "\n" for l in header)) ### Parse input and write to the outputs diff --git a/pairtools/pairtools_parse2.py b/pairtools/cli/parse2.py similarity index 91% rename from pairtools/pairtools_parse2.py rename to pairtools/cli/parse2.py index 4df05deb..8b866f9b 100644 --- a/pairtools/pairtools_parse2.py +++ b/pairtools/cli/parse2.py @@ -1,21 +1,15 @@ # !/usr/bin/env python # -*- coding: utf-8 -*- -from collections import OrderedDict -import subprocess -import fileinput -import itertools import click -import pipes import sys -import os -import io -import pysam -from . import _fileio, _pairsam_format, _parse, _headerops, cli, common_io_options -from .pairtools_stats import PairCounter -from ._parse_pysam import AlignmentFilePairtoolized -from ._parse import streaming_classify +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.stats import PairCounter +from ..lib.parse_pysam import AlignmentFilePairtoolized +from ..lib.parse import streaming_classify UTIL_NAME = "pairtools_parse2" @@ -213,7 +207,7 @@ def parse2_py( ### Set up output streams outstream = ( - _fileio.auto_open( + fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -223,7 +217,7 @@ def parse2_py( else sys.stdout ) out_alignments_stream = ( - _fileio.auto_open( + fileio.auto_open( output_parsed_alignments, mode="w", nproc=kwargs.get("nproc_out"), @@ -233,7 +227,7 @@ def parse2_py( else None ) out_stats_stream = ( - _fileio.auto_open( + fileio.auto_open( output_stats, mode="w", nproc=kwargs.get("nproc_out"), @@ -258,7 +252,7 @@ def parse2_py( if not ((col in EXTRA_COLUMNS) or (len(col) == 2 and col.isupper())): raise Exception("{} is not a valid extra column".format(col)) - columns = _pairsam_format.COLUMNS + ( + columns = pairsam_format.COLUMNS + ( [c + side for c in add_columns for side in ["1", "2"]] ) @@ -278,19 +272,19 @@ def parse2_py( ) ### Parse chromosome files present in the input - sam_chromsizes = _headerops.get_chromsizes_from_pysam_header(samheader) - chromosomes = _headerops.get_chrom_order(chroms_path, list(sam_chromsizes.keys())) + sam_chromsizes = headerops.get_chromsizes_from_pysam_header(samheader) + chromosomes = headerops.get_chrom_order(chroms_path, list(sam_chromsizes.keys())) ### Write new header to the pairsam file - header = _headerops.make_standard_pairsheader( + header = headerops.make_standard_pairsheader( assembly=kwargs.get("assembly", ""), chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], columns=columns, shape="whole matrix" if kwargs["no_flip"] else "upper triangle", ) - header = _headerops.insert_samheader_pysam(header, samheader) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header = headerops.insert_samheader_pysam(header, samheader) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l + "\n" for l in header)) ### Parse input and write to the outputs diff --git a/pairtools/pairtools_phase.py b/pairtools/cli/phase.py similarity index 74% rename from pairtools/pairtools_phase.py rename to pairtools/cli/phase.py index 727d65d8..4cb6f10e 100644 --- a/pairtools/pairtools_phase.py +++ b/pairtools/cli/phase.py @@ -2,7 +2,8 @@ import click import re, fnmatch -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_phase" @@ -42,38 +43,38 @@ def phase(pairs_path, output, phase_suffixes, clean_output, **kwargs): def phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - old_column_names = _headerops.extract_column_names(header) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + old_column_names = headerops.extract_column_names(header) if clean_output: new_column_names = [ - col for col in old_column_names if col in _pairsam_format.COLUMNS + col for col in old_column_names if col in pairsam_format.COLUMNS ] new_column_idxs = [ i for i, col in enumerate(old_column_names) - if col in _pairsam_format.COLUMNS + if col in pairsam_format.COLUMNS ] + [len(old_column_names), len(old_column_names) + 1] else: new_column_names = list(old_column_names) new_column_names.append("phase1") new_column_names.append("phase2") - header = _headerops._update_header_entry( + header = headerops._update_header_entry( header, "columns", " ".join(new_column_names) ) @@ -133,15 +134,15 @@ def phase_side(chrom, XB, AS, XS, phase_suffixes): return "!", "!" for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) + cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) cols.append("!") cols.append("!") - pair_type = cols[_pairsam_format.COL_PTYPE] + pair_type = cols[pairsam_format.COL_PTYPE] - if cols[_pairsam_format.COL_C1] != _pairsam_format.UNMAPPED_CHROM: + if cols[pairsam_format.COL_C1] != pairsam_format.UNMAPPED_CHROM: phase1, chrom_base1 = phase_side( - cols[_pairsam_format.COL_C1], + cols[pairsam_format.COL_C1], cols[COL_XB1], int(cols[COL_AS1]), int(cols[COL_XS1]), @@ -149,18 +150,18 @@ def phase_side(chrom, XB, AS, XS, phase_suffixes): ) cols[-2] = phase1 - cols[_pairsam_format.COL_C1] = chrom_base1 + cols[pairsam_format.COL_C1] = chrom_base1 if chrom_base1 == "!": - cols[_pairsam_format.COL_C1] = _pairsam_format.UNMAPPED_CHROM - cols[_pairsam_format.COL_P1] = str(_pairsam_format.UNMAPPED_POS) - cols[_pairsam_format.COL_S1] = _pairsam_format.UNMAPPED_STRAND + cols[pairsam_format.COL_C1] = pairsam_format.UNMAPPED_CHROM + cols[pairsam_format.COL_P1] = str(pairsam_format.UNMAPPED_POS) + cols[pairsam_format.COL_S1] = pairsam_format.UNMAPPED_STRAND pair_type = "M" + pair_type[1] - if cols[_pairsam_format.COL_C2] != _pairsam_format.UNMAPPED_CHROM: + if cols[pairsam_format.COL_C2] != pairsam_format.UNMAPPED_CHROM: phase2, chrom_base2 = phase_side( - cols[_pairsam_format.COL_C2], + cols[pairsam_format.COL_C2], cols[COL_XB2], int(cols[COL_AS2]), int(cols[COL_XS2]), @@ -168,20 +169,20 @@ def phase_side(chrom, XB, AS, XS, phase_suffixes): ) cols[-1] = phase2 - cols[_pairsam_format.COL_C2] = chrom_base2 + cols[pairsam_format.COL_C2] = chrom_base2 if chrom_base2 == "!": - cols[_pairsam_format.COL_C2] = _pairsam_format.UNMAPPED_CHROM - cols[_pairsam_format.COL_P2] = str(_pairsam_format.UNMAPPED_POS) - cols[_pairsam_format.COL_S2] = _pairsam_format.UNMAPPED_STRAND + cols[pairsam_format.COL_C2] = pairsam_format.UNMAPPED_CHROM + cols[pairsam_format.COL_P2] = str(pairsam_format.UNMAPPED_POS) + cols[pairsam_format.COL_S2] = pairsam_format.UNMAPPED_STRAND pair_type = pair_type[0] + "M" - cols[_pairsam_format.COL_PTYPE] = pair_type + cols[pairsam_format.COL_PTYPE] = pair_type if clean_output: cols = [cols[i] for i in new_column_idxs] - outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) + outstream.write(pairsam_format.PAIRSAM_SEP.join(cols)) outstream.write("\n") if instream != sys.stdin: diff --git a/pairtools/pairtools_restrict.py b/pairtools/cli/restrict.py similarity index 65% rename from pairtools/pairtools_restrict.py rename to pairtools/cli/restrict.py index 8d1b8303..27684468 100644 --- a/pairtools/pairtools_restrict.py +++ b/pairtools/cli/restrict.py @@ -1,14 +1,15 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -import io import sys import click -import subprocess import warnings import numpy as np -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.restrict import find_rfrag UTIL_NAME = "pairtools_restrict" @@ -47,23 +48,23 @@ def restrict(pairs_path, frags, output, **kwargs): def restrict_py(pairs_path, frags, output, **kwargs): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - header = _headerops.append_columns( + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header = headerops.append_columns( header, [ "rfrag1", @@ -95,14 +96,14 @@ def restrict_py(pairs_path, frags, output, **kwargs): } for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) - chrom1, pos1 = cols[_pairsam_format.COL_C1], int(cols[_pairsam_format.COL_P1]) + cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) + chrom1, pos1 = cols[pairsam_format.COL_C1], int(cols[pairsam_format.COL_P1]) rfrag_idx1, rfrag_start1, rfrag_end1 = find_rfrag(rfrags, chrom1, pos1) - chrom2, pos2 = cols[_pairsam_format.COL_C2], int(cols[_pairsam_format.COL_P2]) + chrom2, pos2 = cols[pairsam_format.COL_C2], int(cols[pairsam_format.COL_P2]) rfrag_idx2, rfrag_start2, rfrag_end2 = find_rfrag(rfrags, chrom2, pos2) cols += [str(rfrag_idx1), str(rfrag_start1), str(rfrag_end1)] cols += [str(rfrag_idx2), str(rfrag_start2), str(rfrag_end2)] - outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) + outstream.write(pairsam_format.PAIRSAM_SEP.join(cols)) outstream.write("\n") if instream != sys.stdin: @@ -111,33 +112,5 @@ def restrict_py(pairs_path, frags, output, **kwargs): outstream.close() -def find_rfrag(rfrags, chrom, pos): - - # Return empty if chromosome is unmapped: - if chrom == _pairsam_format.UNMAPPED_CHROM: - return ( - _pairsam_format.UNANNOTATED_RFRAG, - _pairsam_format.UNMAPPED_POS, - _pairsam_format.UNMAPPED_POS, - ) - - try: - rsites_chrom = rfrags[chrom] - except ValueError as e: - warnings.warn( - f"Chomosome {chrom} does not have annotated restriction fragments, return empty." - ) - return ( - _pairsam_format.UNANNOTATED_RFRAG, - _pairsam_format.UNMAPPED_POS, - _pairsam_format.UNMAPPED_POS, - ) - - idx = min( - max(0, rsites_chrom.searchsorted(pos, "right") - 1), len(rsites_chrom) - 2 - ) - return idx, rsites_chrom[idx], rsites_chrom[idx + 1] - - if __name__ == "__main__": restrict() diff --git a/pairtools/pairtools_sample.py b/pairtools/cli/sample.py similarity index 85% rename from pairtools/pairtools_sample.py rename to pairtools/cli/sample.py index 03310188..5cfef59d 100644 --- a/pairtools/pairtools_sample.py +++ b/pairtools/cli/sample.py @@ -3,7 +3,8 @@ import random -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_sample" @@ -42,21 +43,21 @@ def sample(fraction, pairs_path, output, seed, **kwargs): def sample_py(fraction, pairs_path, output, seed, **kwargs): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) outstream.writelines((l + "\n" for l in header)) random.seed(seed) diff --git a/pairtools/pairtools_select.py b/pairtools/cli/select.py similarity index 92% rename from pairtools/pairtools_select.py rename to pairtools/cli/select.py index 702e59a7..31f610e7 100644 --- a/pairtools/pairtools_select.py +++ b/pairtools/cli/select.py @@ -2,7 +2,8 @@ import click import re, fnmatch -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_select" @@ -135,13 +136,13 @@ def select_py( **kwargs ): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -151,7 +152,7 @@ def select_py( # Optional output created only if requested: outstream_rest = None if output_rest: - outstream_rest = _fileio.auto_open( + outstream_rest = fileio.auto_open( output_rest, mode="w", nproc=kwargs.get("nproc_out"), @@ -190,17 +191,17 @@ def regex_match(x, regex): TYPES.update(dict(type_cast)) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) if new_chroms is not None: - header = _headerops.subset_chroms_in_pairsheader(header, new_chroms) + header = headerops.subset_chroms_in_pairsheader(header, new_chroms) outstream.writelines((l + "\n" for l in header)) if output_rest: outstream_rest.writelines((l + "\n" for l in header)) - column_names = _headerops.extract_column_names(header) + column_names = headerops.extract_column_names(header) if len(column_names) == 0: - column_names = _pairsam_format.COLUMNS + column_names = pairsam_format.COLUMNS if startup_code is not None: exec(startup_code, globals()) @@ -221,7 +222,7 @@ def regex_match(x, regex): match_func = compile(condition, "", "eval") for line in body_stream: - COLS = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) + COLS = line.rstrip().split(pairsam_format.PAIRSAM_SEP) if eval(match_func): outstream.write(line) elif outstream_rest: diff --git a/pairtools/pairtools_sort.py b/pairtools/cli/sort.py similarity index 87% rename from pairtools/pairtools_sort.py rename to pairtools/cli/sort.py index 64972dc4..5b7b0217 100644 --- a/pairtools/pairtools_sort.py +++ b/pairtools/cli/sort.py @@ -7,7 +7,8 @@ import shutil import warnings -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_sort" @@ -71,22 +72,22 @@ def sort(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwargs): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairs_path, mode="r", nproc=kwargs.get("nproc_in"), command=kwargs.get("cmd_in", None), ) - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - header = _headerops.mark_header_as_sorted(header) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + header = headerops.mark_header_as_sorted(header) outstream.writelines((l + "\n" for l in header)) @@ -115,12 +116,12 @@ def sort_py(pairs_path, output, nproc, tmpdir, memory, compress_program, **kwarg """.replace( "\n", " " ).format( - _pairsam_format.COL_C1 + 1, - _pairsam_format.COL_C2 + 1, - _pairsam_format.COL_P1 + 1, - _pairsam_format.COL_P2 + 1, - _pairsam_format.COL_PTYPE + 1, - _pairsam_format.PAIRSAM_SEP_ESCAPE, + pairsam_format.COL_C1 + 1, + pairsam_format.COL_C2 + 1, + pairsam_format.COL_P1 + 1, + pairsam_format.COL_P2 + 1, + pairsam_format.COL_PTYPE + 1, + pairsam_format.PAIRSAM_SEP_ESCAPE, " --parallel={} ".format(nproc) if nproc > 0 else " ", " --temporary-directory={} ".format(tmpdir) if tmpdir else " ", memory, diff --git a/pairtools/pairtools_split.py b/pairtools/cli/split.py similarity index 84% rename from pairtools/pairtools_split.py rename to pairtools/cli/split.py index f8c23de1..40f1c6fc 100644 --- a/pairtools/pairtools_split.py +++ b/pairtools/cli/split.py @@ -4,7 +4,8 @@ import pipes import click -from . import _fileio, _pairsam_format, _headerops, cli, common_io_options +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options UTIL_NAME = "pairtools_split" @@ -44,7 +45,7 @@ def split(pairsam_path, output_pairs, output_sam, **kwargs): def split_py(pairsam_path, output_pairs, output_sam, **kwargs): - instream = _fileio.auto_open( + instream = fileio.auto_open( pairsam_path, mode="r", nproc=kwargs.get("nproc_in"), @@ -61,23 +62,23 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): outstream_sam = None if output_pairs: - outstream_pairs = _fileio.auto_open( + outstream_pairs = fileio.auto_open( output_pairs, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) if output_sam: - outstream_sam = _fileio.auto_open( + outstream_sam = fileio.auto_open( output_sam, mode="w", nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - columns = _headerops.extract_column_names(header) + header, body_stream = headerops.get_header(instream) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + columns = headerops.extract_column_names(header) has_sams = False if columns: @@ -87,7 +88,7 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): sam2col = columns.index("sam2") columns.pop(max(sam1col, sam2col)) columns.pop(min(sam1col, sam2col)) - header = _headerops._update_header_entry( + header = headerops._update_header_entry( header, "columns", " ".join(columns) ) has_sams = True @@ -97,8 +98,8 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): ) else: # assume that the file has sam columns and follows the pairsam format - sam1col = _pairsam_format.COL_SAM1 - sam2col = _pairsam_format.COL_SAM2 + sam1col = pairsam_format.COL_SAM1 + sam2col = pairsam_format.COL_SAM2 has_sams = True if output_pairs: @@ -112,7 +113,7 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): sam1 = None sam2 = None for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) + cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) if has_sams: if sam1col < sam2col: sam2 = cols.pop(sam2col) @@ -129,9 +130,9 @@ def split_py(pairsam_path, output_pairs, output_sam, **kwargs): if output_sam and has_sams: for col in (sam1, sam2): if col != ".": - for sam_entry in col.split(_pairsam_format.INTER_SAM_SEP): + for sam_entry in col.split(pairsam_format.INTER_SAM_SEP): outstream_sam.write( - sam_entry.replace(_pairsam_format.SAM_SEP, "\t") + sam_entry.replace(pairsam_format.SAM_SEP, "\t") ) outstream_sam.write("\n") diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py new file mode 100644 index 00000000..19bd6f79 --- /dev/null +++ b/pairtools/cli/stats.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import io +import sys +import click + +import pandas as pd +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.stats import PairCounter, do_merge + + +UTIL_NAME = "pairtools_stats" + + +@cli.command() +@click.argument("input_path", type=str, nargs=-1, required=False) +@click.option("-o", "--output", type=str, default="", help="output stats tsv file.") +@click.option( + "--merge", + is_flag=True, + help="If specified, merge multiple input stats files instead of calculating" + " statistics of a .pairs/.pairsam file. Merging is performed via summation of" + " all overlapping statistics. Non-overlapping statistics are appended to" + " the end of the file.", +) +@common_io_options +def stats(input_path, output, merge, **kwargs): + """Calculate pairs statistics. + + INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. + If not provided, the input is read from stdin. + If --merge is specified, then INPUT_PATH is interpreted as an arbitrary number + of stats files to merge. + + The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. + """ + stats_py(input_path, output, merge, **kwargs) + + +def stats_py(input_path, output, merge, **kwargs): + if merge: + do_merge(output, input_path, **kwargs) + return + + instream = fileio.auto_open( + input_path[0], + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + header, body_stream = headerops.get_header(instream) + cols = headerops.extract_column_names(header) + + # new stats class stuff would come here ... + stats = PairCounter() + + # Collecting statistics + + for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): + stats.add_pairs_from_dataframe(chunk) + + # save statistics to file ... + stats.save(outstream) + + if instream != sys.stdin: + instream.close() + if outstream != sys.stdout: + outstream.close() + + +if __name__ == "__main__": + stats() diff --git a/pairtools/lib/__init__.py b/pairtools/lib/__init__.py new file mode 100644 index 00000000..b57ae2e9 --- /dev/null +++ b/pairtools/lib/__init__.py @@ -0,0 +1,11 @@ +from . import fileio +from . import dedup +from . import dedup_cython +from . import filterbycov +from . import headerops +from . import markasdup +from . import pairsam_format +from . import parse +from . import parse_pysam +from . import restrict +from . import stats diff --git a/pairtools/pairtools_dedup.py b/pairtools/lib/dedup.py similarity index 54% rename from pairtools/pairtools_dedup.py rename to pairtools/lib/dedup.py index 6e36898c..a30a2444 100644 --- a/pairtools/pairtools_dedup.py +++ b/pairtools/lib/dedup.py @@ -1,501 +1,24 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -from distutils.log import warn -import sys -import ast -import warnings -import pathlib - -import click - import numpy as np import pandas as pd +import warnings import scipy.spatial from scipy.sparse import coo_matrix from scipy.sparse.csgraph import connected_components -from . import _dedup, _fileio, _pairsam_format, _headerops, cli, common_io_options -from .pairtools_markasdup import mark_split_pair_as_dup -from .pairtools_stats import PairCounter +from . import dedup_cython, pairsam_format +from .markasdup import mark_split_pair_as_dup +from .stats import PairCounter import time -UTIL_NAME = "pairtools_dedup" - +# Setting for cython deduplication: # you don't need to load more than 10k lines at a time b/c you get out of the # CPU cache, so this parameter is not adjustable MAX_LEN = 10000 -@cli.command() -@click.argument("pairs_path", type=str, required=False) - -### Output files: -@click.option( - "-o", - "--output", - type=str, - default="", - help="output file for pairs after duplicate removal." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, the output is printed into stdout.", -) -@click.option( - "--output-dups", - type=str, - default="", - help="output file for duplicated pairs. " - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " If the path is the same as in --output or -, output duplicates together " - " with deduped pairs. By default, duplicates are dropped.", -) -@click.option( - "--output-unmapped", - type=str, - default="", - help="output file for unmapped pairs. " - "If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. " - "If the path is the same as in --output or -, output unmapped pairs together " - "with deduped pairs. If the path is the same as --output-dups, output " - "unmapped reads together with dups. By default, unmapped pairs are dropped.", -) -@click.option( - "--output-stats", - type=str, - default="", - help="output file for duplicate statistics." - " If file exists, it will be open in the append mode." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, statistics are not printed.", -) - -### Set the dedup method: -@click.option( - "--max-mismatch", - type=int, - default=3, - show_default=True, - help="Pairs with both sides mapped within this distance (bp) from each " - "other are considered duplicates. ", -) -@click.option( - "--method", - type=click.Choice(["max", "sum"]), - default="max", - help="define the mismatch as either the max or the sum of the mismatches of" - "the genomic locations of the both sides of the two compared molecules", - show_default=True, -) -@click.option( - "--backend", - type=click.Choice(["scipy", "sklearn", "cython"]), - default="scipy", - help="What backend to use: scipy and sklearn are based on KD-trees," - " cython is online indexed list-based algorithm." - " With cython backend, duplication is not transitive with non-zero max mismatch " - " (e.g. pairs A and B are duplicates, and B and C are duplicates, then A and C are " - " not necessary duplicates of each other), while with scipy and sklearn it's " - " transitive (i.e. A and C are necessarily duplicates)." - " Cython is the original version used in pairtools since its beginning." - " It is available for backwards compatibility and to allow specification of the" - " column order." - " Now the default scipy backend is generally the fastest, and with chunksize below" - " 1 mln has the lowest memory requirements." - # " 'cython' is deprecated and provided for backwards compatibility", -) - -### Scipy and sklearn-specific options: -@click.option( - "--chunksize", - type=int, - default=100_000, - show_default=True, - help="Number of pairs in each chunk. Reduce for lower memory footprint." - " Below 10,000 performance starts suffering significantly and the algorithm might" - " miss a few duplicates with non-zero --max-mismatch." - " Only works with '--backend scipy or sklearn'", -) -@click.option( - "--carryover", - type=int, - default=100, - show_default=True, - help="Number of deduped pairs to carry over from previous chunk to the new chunk" - " to avoid breaking duplicate clusters." - " Only works with '--backend scipy or sklearn'", -) -@click.option( - "-p", - "--n-proc", - type=int, - default=1, - help="Number of cores to use. Only applies with sklearn backend." - "Still needs testing whether it is ever useful.", -) - -### Output options: -@click.option( - "--mark-dups", - is_flag=True, - help='If specified, duplicate pairs are marked as DD in "pair_type" and ' - "as a duplicate in the sam entries.", -) -@click.option( - "--keep-parent-id", - is_flag=True, - help="If specified, duplicate pairs are marked with the readID of the retained" - " deduped read in the 'parent_readID' field.", -) -@click.option( - "--extra-col-pair", - nargs=2, - # type=click.Tuple([str, str]), - multiple=True, - help="Extra columns that also must match for two pairs to be marked as " - "duplicates. Can be either provided as 0-based column indices or as column " - 'names (requires the "#columns" header field). The option can be provided ' - "multiple times if multiple column pairs must match. " - 'Example: --extra-col-pair "phase1" "phase2"', -) - -### Input options: -@click.option( - "--sep", - type=str, - default=_pairsam_format.PAIRSAM_SEP_ESCAPE, - help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", -) -@click.option( - "--comment-char", type=str, default="#", help="The first character of comment lines" -) -@click.option( - "--send-header-to", - type=click.Choice(["dups", "dedup", "both", "none"]), - default="both", - help="Which of the outputs should receive header and comment lines", -) -@click.option( - "--c1", - type=int, - default=_pairsam_format.COL_C1, - help=f"Chrom 1 column; default {_pairsam_format.COL_C1}" - " Only works with '--backend cython'", -) -@click.option( - "--c2", - type=int, - default=_pairsam_format.COL_C2, - help=f"Chrom 2 column; default {_pairsam_format.COL_C2}" - " Only works with '--backend cython'", -) -@click.option( - "--p1", - type=int, - default=_pairsam_format.COL_P1, - help=f"Position 1 column; default {_pairsam_format.COL_P1}" - " Only works with '--backend cython'", -) -@click.option( - "--p2", - type=int, - default=_pairsam_format.COL_P2, - help=f"Position 2 column; default {_pairsam_format.COL_P2}" - " Only works with '--backend cython'", -) -@click.option( - "--s1", - type=int, - default=_pairsam_format.COL_S1, - help=f"Strand 1 column; default {_pairsam_format.COL_S1}" - " Only works with '--backend cython'", -) -@click.option( - "--s2", - type=int, - default=_pairsam_format.COL_S2, - help=f"Strand 2 column; default {_pairsam_format.COL_S2}" - " Only works with '--backend cython'", -) -@click.option( - "--unmapped-chrom", - type=str, - default=_pairsam_format.UNMAPPED_CHROM, - help="Placeholder for a chromosome on an unmapped side; default {}".format( - _pairsam_format.UNMAPPED_CHROM - ), -) -@common_io_options -def dedup( - pairs_path, - output, - output_dups, - output_unmapped, - output_stats, - chunksize, - carryover, - max_mismatch, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_dups, - extra_col_pair, - keep_parent_id, - backend, - n_proc, - **kwargs, -): - """Find and remove PCR/optical duplicates. - - Find PCR duplicates in an upper-triangular flipped sorted pairs/pairsam - file. Allow for a +/-N bp mismatch at each side of duplicated molecules. - - PAIRS_PATH : input triu-flipped sorted .pairs or .pairsam file. If the - path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. - By default, the input is read from stdin. - """ - - dedup_py( - pairs_path, - output, - output_dups, - output_unmapped, - output_stats, - chunksize, - carryover, - max_mismatch, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_dups, - extra_col_pair, - keep_parent_id, - backend, - n_proc, - **kwargs, - ) - - -if __name__ == "__main__": - dedup() - - -def dedup_py( - pairs_path, - output, - output_dups, - output_unmapped, - output_stats, - chunksize, - carryover, - max_mismatch, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_dups, - extra_col_pair, - keep_parent_id, - backend, - n_proc, - **kwargs, -): - - sep = ast.literal_eval('"""' + sep + '"""') - send_header_to_dedup = send_header_to in ["both", "dedup"] - send_header_to_dup = send_header_to in ["both", "dups"] - - instream = ( - _fileio.auto_open( - pairs_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - if pairs_path - else sys.stdin - ) - outstream = ( - _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout - ) - out_stats_stream = ( - _fileio.auto_open( - output_stats, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output_stats - else None - ) - - # generate empty PairCounter if stats output is requested: - out_stat = PairCounter() if output_stats else None - - if not output_dups: - outstream_dups = None - elif output_dups == "-" or ( - pathlib.Path(output_dups).absolute() == pathlib.Path(output).absolute() - ): - outstream_dups = outstream - else: - outstream_dups = _fileio.auto_open( - output_dups, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - if not output_unmapped: - outstream_unmapped = None - elif output_unmapped == "-" or ( - pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute() - ): - outstream_unmapped = outstream - elif ( - pathlib.Path(output_unmapped).absolute() == pathlib.Path(output_dups).absolute() - ): - outstream_unmapped = outstream_dups - else: - outstream_unmapped = _fileio.auto_open( - output_unmapped, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - if send_header_to_dedup: - outstream.writelines((l + "\n" for l in header)) - if send_header_to_dup and outstream_dups and (outstream_dups != outstream): - dups_header = header - if keep_parent_id and len(dups_header) > 0: - dups_header = _headerops.append_columns(dups_header, ["parent_readID"]) - outstream_dups.writelines((l + "\n" for l in dups_header)) - if ( - outstream_unmapped - and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_dups) - ): - outstream_unmapped.writelines((l + "\n" for l in header)) - - column_names = _headerops.extract_column_names(header) - extra_cols1 = [] - extra_cols2 = [] - if extra_col_pair is not None: - for col1, col2 in extra_col_pair: - extra_cols1.append(column_names[col1] if col1.isdigit() else col1) - extra_cols2.append(column_names[col2] if col2.isdigit() else col2) - - if backend == "cython": - # warnings.warn( - # "'cython' backend is deprecated and provided only" - # " for backwards compatibility", - # DeprecationWarning, - # ) - extra_cols1 = [column_names.index(col) for col in extra_cols1] - extra_cols2 = [column_names.index(col) for col in extra_cols2] - streaming_dedup_cython( - method, - max_mismatch, - sep, - c1, - c2, - p1, - p2, - s1, - s2, - extra_cols1, - extra_cols2, - unmapped_chrom, - body_stream, - outstream, - outstream_dups, - outstream_unmapped, - out_stat, - mark_dups, - keep_parent_id, - ) - elif backend in ("scipy", "sklearn"): - streaming_dedup( - in_stream=instream, - colnames=column_names, - chunksize=chunksize, - carryover=carryover, - method=method, - mark_dups=mark_dups, - max_mismatch=max_mismatch, - extra_col_pairs=list(extra_col_pair), - keep_parent_id=keep_parent_id, - unmapped_chrom=unmapped_chrom, - comment_char=comment_char, - outstream=outstream, - outstream_dups=outstream_dups, - outstream_unmapped=outstream_unmapped, - out_stat=out_stat, - backend=backend, - n_proc=n_proc, - ) - else: - raise ValueError("Unknown backend") - - # save statistics to a file if it was requested: - if out_stat: - out_stat.save(out_stats_stream) - - if instream != sys.stdin: - instream.close() - - if outstream != sys.stdout: - outstream.close() - - if outstream_dups and (outstream_dups != outstream): - outstream_dups.close() - - if ( - outstream_unmapped - and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_dups) - ): - outstream_unmapped.close() - - if out_stats_stream: - out_stats_stream.close() - - -### Cython deduplication #### def streaming_dedup( in_stream, colnames, @@ -759,6 +282,7 @@ def _dedup_chunk( return df +### Cython deduplication #### def streaming_dedup_cython( method, max_mismatch, @@ -821,10 +345,10 @@ def streaming_dedup_cython( # if we do stats in the dedup, we need PAIR_TYPE # i do not see way around this: if out_stat: - ptind = _pairsam_format.COL_PTYPE + ptind = pairsam_format.COL_PTYPE maxind = max(maxind, ptind) - dd = _dedup.OnlineDuplicateDetector( + dd = dedup_cython.OnlineDuplicateDetector( method, max_mismatch, returnData=False, keep_parent_id=keep_parent_id ) diff --git a/pairtools/_dedup.pyx b/pairtools/lib/dedup_cython.pyx similarity index 63% rename from pairtools/_dedup.pyx rename to pairtools/lib/dedup_cython.pyx index 2c08db9a..67a4fbe5 100644 --- a/pairtools/_dedup.pyx +++ b/pairtools/lib/dedup_cython.pyx @@ -17,122 +17,6 @@ cimport numpy as np cimport cython -### Legacy offfline deduplicator: -def mark_duplicates( - cython.int [:] c1, - cython.int [:] c2, - cython.int [:] p1, - cython.int [:] p2, - cython.int [:] s1, - cython.int [:] s2, - #uncomment for testing probably since it will do boundary check - #np.ndarray[np.int16_t, ndim=1]c2, - #np.ndarray[np.int32_t, ndim=1] p1, - #np.ndarray[np.int32_t, ndim=1] p2, - #np.ndarray[np.int8_t, ndim=1] s1, - #np.ndarray[np.int8_t, ndim=1] s2, - int max_mismatch=3, - method = "sum"): - """ - Mark duplicates, allowing for some mismatch on the both sides of the molecule. - You can use it to filter single-cell data as well by setting max_mismatch to - 500bp or even larger. It works as fast as we could make it. - This methods scans through a list of reads. It then flags duplicates, - which are defined as molecules, with both ends located within `max_mismatch` - bp from each other. - - There are two ways define duplicates: - "max": two reads are duplicates if the mismatch of the genomic locations - of both ends is less-or-equal "max_mismatch" - "sum": two reads are duplicates if the sum of the mismatches of the either - ends of the molecule is less-or-equal "max_mismatch" - Other methods could be added below by editing the code - - Parameters - ---------- - c1, c2 : int32 array - chromosome IDs - - p1, p2 : int32 arrays - positions - - s1, s2 : int32 (or bool) arrays - strands - - max_mismatch : int - method : "sum" or "max" - use the sum of mismatches, or the max of the two - - Returns - ------- - mask : int8 array - A binary mask, where 1 denotes that a read is a duplicate. - Notes - ----- - Arrays MUST be ordered by (c1, p1) - - """ - cdef int N = len(c1) - cdef np.ndarray[np.int8_t, ndim=1] mask = np.zeros(N, dtype=np.int8) - cdef int low = 0 - cdef int high = 1 - cdef int extraCondition - cdef int methodid - - if method == "max": - methodid = 0 - elif method == "sum": - methodid = 1 - else: - raise ValueError('method should be "sum" or "max"') - - while True: - assert False - if low == N: - break - - if high == N: - low += 1 - high = low + 1 - continue - - if mask[low] == 1: - low += 1 - high = low+1 - continue - - # if high already removed, just continue - if mask[high] == 1: - high += 1 - continue - - # if we jumped too far, continue - if (c1[high] != c1[low]) or (p1[high] - p1[low] > max_mismatch) or (p1[high] < p1[low]) or (c2[high] != c2[low]): - low += 1 - high = low + 1 # restart high - continue - - if methodid == 0: - extraCondition = (max(abs(p1[low] - p1[high]), - abs(p2[low] - p2[high])) <= max_mismatch) - elif methodid == 1: - extraCondition = (abs(p1[low] - p1[high]) + - abs(p2[low] - p2[high]) <= max_mismatch) - else: - raise ValueError( - "Unknown method id, this should not happen. " - "Check code of this function.") - - if ((c2[low] == c2[high]) and (s1[low] == s1[high]) and - (s2[low] == s2[high]) and extraCondition): - mask[high] = 1 - high += 1 - continue - high += 1 - - return mask - - ### Online deduplicator used in pairtools.dedup Cython: cdef class OnlineDuplicateDetector(object): cdef cython.int [:] c1 diff --git a/pairtools/_fileio.py b/pairtools/lib/fileio.py similarity index 100% rename from pairtools/_fileio.py rename to pairtools/lib/fileio.py diff --git a/pairtools/lib/filterbycov.py b/pairtools/lib/filterbycov.py new file mode 100644 index 00000000..ddc6bbb2 --- /dev/null +++ b/pairtools/lib/filterbycov.py @@ -0,0 +1,256 @@ +import numpy as np +import warnings + +from .markasdup import mark_split_pair_as_dup +from . import pairsam_format + + +def fetchadd(key, mydict): + key = key.strip() + if key not in mydict: + mydict[key] = len(mydict) + return mydict[key] + + +def ar(mylist, val): + return np.array(mylist, dtype={8: np.int8, 16: np.int16, 32: np.int32}[val]) + + +def _filterbycov(c1_in, p1_in, c2_in, p2_in, max_dist, method): + """ + This is a slow version of the filtering code used for testing purposes only + Use cythonized version in the future!! + """ + + c1 = np.asarray(c1_in, dtype=int) + p1 = np.asarray(p1_in, dtype=int) + c2 = np.asarray(c2_in, dtype=int) + p2 = np.asarray(p2_in, dtype=int) + + M = np.r_[ + np.c_[c1, p1], np.c_[c2, p2] + ] # M is a table of (chrom, pos) with 2*N rows + + assert c1.shape[0] == c2.shape[0] + N = 2 * c1.shape[0] + + ind_sorted = np.lexsort((M[:, 1], M[:, 0])) # sort by chromosomes, then positions + # M[ind_sorted] + # ind_sorted + # M, M[ind_sorted] + + if method == "sum": + proximity_count = np.zeros( + N + ) # keeps track of how many molecules each framgent end is close to + elif method == "max": + proximity_count = np.zeros(N) + else: + raise ValueError("Unknown method: {}".format(method)) + + low = 0 + high = 1 + while True: + + # boundary case finish + if low == N: + break + + # boundary case - CHECK + if high == N: + low += 1 + high = low + 1 + continue + + # check if "high" is proximal enough to "low" + + # first, if chromosomes not equal, we have gone too far, and the positions are not proximal + if M[ind_sorted[low], 0] != M[ind_sorted[high], 0]: + low += 1 + high = low + 1 # restart high + continue + + # next, if positions are not proximal, increase low, and continue + elif np.abs(M[ind_sorted[high], 1] - M[ind_sorted[low], 1]) > max_dist: + low += 1 + high = low + 1 # restart high + continue + + # if on the same chromosome, and the distance is "proximal enough", add to count of both "low" and "high" positions + else: + proximity_count[low] += 1 + proximity_count[high] += 1 + + high += 1 + + # unsort proximity count + # proximity_count = proximity_count[ind_sorted] + proximity_count[ind_sorted] = np.copy(proximity_count) + # print(M) + # print(proximity_count) + + # if method is sum of pairs + if method == "sum": + pcounts = proximity_count[0 : N // 2] + proximity_count[N // 2 :] + 1 + elif method == "max": + pcounts = np.maximum( + proximity_count[0 : N // 2] + 1, proximity_count[N // 2 :] + 1 + ) + else: + raise ValueError("Unknown method: {}".format(method)) + + return pcounts + + +def streaming_filterbycov( + method, + max_dist, + max_cov, + sep, + c1ind, + c2ind, + p1ind, + p2ind, + s1ind, + s2ind, + unmapped_chrom, + instream, + outstream, + outstream_high, + outstream_unmapped, + out_stat, + mark_multi, +): + + # doing everything in memory + maxind = max(c1ind, c2ind, p1ind, p2ind, s1ind, s2ind) + + # if we do stats in the dedup, we need PAIR_TYPE + # i do not see way around this: + if out_stat: + ptind = pairsam_format.COL_PTYPE + maxind = max(maxind, ptind) + + c1 = [] + c2 = [] + p1 = [] + p2 = [] + s1 = [] + s2 = [] + line_buffer = [] + cols_buffer = [] + chromDict = {} + strandDict = {} + n_unmapped = 0 + n_high = 0 + n_low = 0 + + instream = iter(instream) + while True: + rawline = next(instream, None) + stripline = rawline.strip() if rawline else None + + # take care of empty lines not at the end of the file separately + if rawline and (not stripline): + warnings.warn("Empty line detected not at the end of the file") + continue + + if stripline: + cols = stripline.split(sep) + if len(cols) <= maxind: + raise ValueError( + "Error parsing line {}: ".format(stripline) + + " expected {} columns, got {}".format(maxind, len(cols)) + ) + + if (cols[c1ind] == unmapped_chrom) or (cols[c2ind] == unmapped_chrom): + + if outstream_unmapped: + outstream_unmapped.write(stripline) + # don't forget terminal newline + outstream_unmapped.write("\n") + + # add a pair to PairCounter if stats output is requested: + if out_stat: + out_stat.add_pair( + cols[c1ind], + int(cols[p1ind]), + cols[s1ind], + cols[c2ind], + int(cols[p2ind]), + cols[s2ind], + cols[ptind], + ) + else: + line_buffer.append(stripline) + cols_buffer.append(cols) + + c1.append(fetchadd(cols[c1ind], chromDict)) + c2.append(fetchadd(cols[c2ind], chromDict)) + p1.append(int(cols[p1ind])) + p2.append(int(cols[p2ind])) + s1.append(fetchadd(cols[s1ind], strandDict)) + s2.append(fetchadd(cols[s2ind], strandDict)) + + else: # when everything is loaded in memory... + + res = _filterbycov(c1, p1, c2, p2, max_dist, method) + + for i in range(len(res)): + # not high-frequency interactor pairs: + if not res[i] > max_cov: + outstream.write(line_buffer[i]) + # don't forget terminal newline + outstream.write("\n") + if out_stat: + out_stat.add_pair( + cols_buffer[i][c1ind], + int(cols_buffer[i][p1ind]), + cols_buffer[i][s1ind], + cols_buffer[i][c2ind], + int(cols_buffer[i][p2ind]), + cols_buffer[i][s2ind], + cols_buffer[i][ptind], + ) + # high-frequency interactor pairs: + else: + if out_stat: + out_stat.add_pair( + cols_buffer[i][c1ind], + int(cols_buffer[i][p1ind]), + cols_buffer[i][s1ind], + cols_buffer[i][c2ind], + int(cols_buffer[i][p2ind]), + cols_buffer[i][s2ind], + "FF", + ) + if outstream_high: + outstream_high.write( + # FF-marked pair: + sep.join(mark_split_pair_as_dup(cols_buffer[i])) + if mark_multi + # pair as is: + else line_buffer[i] + ) + # don't forget terminal newline + outstream_high.write("\n") + + # flush buffers and perform necessary checks here: + c1 = [] + c2 = [] + p1 = [] + p2 = [] + s1 = [] + s2 = [] + line_buffer = line_buffer[len(res) :] + cols_buffer = cols_buffer[len(res) :] + if not stripline: + if len(line_buffer) != 0: + raise ValueError( + "{} lines left in the buffer, ".format(len(line_buffer)) + + "should be none;" + + "something went terribly wrong" + ) + break + + break diff --git a/pairtools/_headerops.py b/pairtools/lib/headerops.py similarity index 99% rename from pairtools/_headerops.py rename to pairtools/lib/headerops.py index 54746f09..7221a562 100644 --- a/pairtools/_headerops.py +++ b/pairtools/lib/headerops.py @@ -7,8 +7,9 @@ import numpy as np import pandas as pd -from . import __version__, _pairsam_format -from ._fileio import ParseError +from .. import __version__ +from . import pairsam_format +from .fileio import ParseError PAIRS_FORMAT_VERSION = "1.0.0" @@ -176,7 +177,7 @@ def get_chrom_order(chroms_file, sam_chroms=None): def make_standard_pairsheader( assembly=None, chromsizes=None, - columns=_pairsam_format.COLUMNS, + columns=pairsam_format.COLUMNS, shape="upper triangle", ): header = [] diff --git a/pairtools/lib/markasdup.py b/pairtools/lib/markasdup.py new file mode 100644 index 00000000..8f87c5e2 --- /dev/null +++ b/pairtools/lib/markasdup.py @@ -0,0 +1,40 @@ +from . import pairsam_format + + +def mark_split_pair_as_dup(cols): + # if the original columns ended with a new line, the marked columns + # should as well. + original_has_newline = cols[-1].endswith("\n") + + cols[pairsam_format.COL_PTYPE] = "DD" + + if (len(cols) > pairsam_format.COL_SAM1) and (len(cols) > pairsam_format.COL_SAM2): + for i in (pairsam_format.COL_SAM1, pairsam_format.COL_SAM2): + + # split each sam column into sam entries, tag and assemble back + cols[i] = pairsam_format.INTER_SAM_SEP.join( + [ + mark_sam_as_dup(sam) + for sam in cols[i].split(pairsam_format.INTER_SAM_SEP) + ] + ) + + if original_has_newline and not cols[-1].endswith("\n"): + cols[-1] = cols[-1] + "\n" + return cols + + +def mark_sam_as_dup(sam): + """Tag the binary flag and the optional pair type field of a sam entry + as a PCR duplicate.""" + samcols = sam.split(pairsam_format.SAM_SEP) + + if len(samcols) == 1: + return sam + + samcols[1] = str(int(samcols[1]) | 1024) + + for j in range(11, len(samcols)): + if samcols[j].startswith("Yt:Z:"): + samcols[j] = "Yt:Z:DD" + return pairsam_format.SAM_SEP.join(samcols) diff --git a/pairtools/_pairsam_format.py b/pairtools/lib/pairsam_format.py similarity index 100% rename from pairtools/_pairsam_format.py rename to pairtools/lib/pairsam_format.py diff --git a/pairtools/_parse.py b/pairtools/lib/parse.py similarity index 97% rename from pairtools/_parse.py rename to pairtools/lib/parse.py index c6778d4a..a035e3cc 100644 --- a/pairtools/_parse.py +++ b/pairtools/lib/parse.py @@ -34,8 +34,7 @@ Additionally, these functions also output all alignments for each side. """ - -from . import _pairsam_format +from . import pairsam_format def streaming_classify( @@ -71,7 +70,7 @@ def streaming_classify( ### Store output parameters in a usable form: chrom_enum = dict( zip( - [_pairsam_format.UNMAPPED_CHROM] + list(chromosomes), + [pairsam_format.UNMAPPED_CHROM] + list(chromosomes), range(len(chromosomes) + 1), ) ) @@ -210,11 +209,11 @@ def push_pysam(sam_entry, sams1, sams2): def empty_alignment(): return { - "chrom": _pairsam_format.UNMAPPED_CHROM, - "pos5": _pairsam_format.UNMAPPED_POS, - "pos3": _pairsam_format.UNMAPPED_POS, - "pos": _pairsam_format.UNMAPPED_POS, - "strand": _pairsam_format.UNMAPPED_STRAND, + "chrom": pairsam_format.UNMAPPED_CHROM, + "pos5": pairsam_format.UNMAPPED_POS, + "pos3": pairsam_format.UNMAPPED_POS, + "pos": pairsam_format.UNMAPPED_POS, + "strand": pairsam_format.UNMAPPED_STRAND, "dist_to_5": 0, "dist_to_3": 0, "mapq": 0, @@ -272,15 +271,15 @@ def parse_pysam_entry( pos3 = sam.reference_start + 1 else: - chrom = _pairsam_format.UNMAPPED_CHROM - strand = _pairsam_format.UNMAPPED_STRAND - pos5 = _pairsam_format.UNMAPPED_POS - pos3 = _pairsam_format.UNMAPPED_POS + chrom = pairsam_format.UNMAPPED_CHROM + strand = pairsam_format.UNMAPPED_STRAND + pos5 = pairsam_format.UNMAPPED_POS + pos3 = pairsam_format.UNMAPPED_POS else: - chrom = _pairsam_format.UNMAPPED_CHROM - strand = _pairsam_format.UNMAPPED_STRAND - pos5 = _pairsam_format.UNMAPPED_POS - pos3 = _pairsam_format.UNMAPPED_POS + chrom = pairsam_format.UNMAPPED_CHROM + strand = pairsam_format.UNMAPPED_STRAND + pos5 = pairsam_format.UNMAPPED_POS + pos3 = pairsam_format.UNMAPPED_POS dist_to_5 = 0 dist_to_3 = 0 @@ -325,11 +324,11 @@ def mask_alignment(algn): """ Reset the coordinates of an alignment. """ - algn["chrom"] = _pairsam_format.UNMAPPED_CHROM - algn["pos5"] = _pairsam_format.UNMAPPED_POS - algn["pos3"] = _pairsam_format.UNMAPPED_POS - algn["pos"] = _pairsam_format.UNMAPPED_POS - algn["strand"] = _pairsam_format.UNMAPPED_STRAND + algn["chrom"] = pairsam_format.UNMAPPED_CHROM + algn["pos5"] = pairsam_format.UNMAPPED_POS + algn["pos3"] = pairsam_format.UNMAPPED_POS + algn["pos"] = pairsam_format.UNMAPPED_POS + algn["strand"] = pairsam_format.UNMAPPED_STRAND return algn @@ -1243,8 +1242,8 @@ def check_pair_order(algn1, algn2, chrom_enum): # If a pair has coordinates on both sides, it must be flipped according to # its genomic coordinates. - if (algn1["chrom"] != _pairsam_format.UNMAPPED_CHROM) and ( - algn2["chrom"] != _pairsam_format.UNMAPPED_CHROM + if (algn1["chrom"] != pairsam_format.UNMAPPED_CHROM) and ( + algn2["chrom"] != pairsam_format.UNMAPPED_CHROM ): has_correct_order = (chrom_enum[algn1["chrom"]], algn1["pos"]) <= ( chrom_enum[algn2["chrom"]], @@ -1328,12 +1327,12 @@ def write_pairsam( sam.query_qualities = "" sam.query_sequence = "" cols.append( - _pairsam_format.INTER_SAM_SEP.join( + pairsam_format.INTER_SAM_SEP.join( [ sam.to_string().replace( - "\t", _pairsam_format.SAM_SEP + "\t", pairsam_format.SAM_SEP ) # String representation of pysam alignment - + _pairsam_format.SAM_SEP + + pairsam_format.SAM_SEP + "Yt:Z:" + algn1["type"] + algn2["type"] @@ -1350,4 +1349,4 @@ def write_pairsam( cols.append(str(algn1.get(col, ""))) cols.append(str(algn2.get(col, ""))) - out_file.write(_pairsam_format.PAIRSAM_SEP.join(cols) + "\n") + out_file.write(pairsam_format.PAIRSAM_SEP.join(cols) + "\n") diff --git a/pairtools/_parse_pysam.pyx b/pairtools/lib/parse_pysam.pyx similarity index 100% rename from pairtools/_parse_pysam.pyx rename to pairtools/lib/parse_pysam.pyx diff --git a/pairtools/lib/restrict.py b/pairtools/lib/restrict.py new file mode 100644 index 00000000..986da2d9 --- /dev/null +++ b/pairtools/lib/restrict.py @@ -0,0 +1,29 @@ +from . import pairsam_format +import warnings + +def find_rfrag(rfrags, chrom, pos): + + # Return empty if chromosome is unmapped: + if chrom == pairsam_format.UNMAPPED_CHROM: + return ( + pairsam_format.UNANNOTATED_RFRAG, + pairsam_format.UNMAPPED_POS, + pairsam_format.UNMAPPED_POS, + ) + + try: + rsites_chrom = rfrags[chrom] + except ValueError as e: + warnings.warn( + f"Chomosome {chrom} does not have annotated restriction fragments, return empty." + ) + return ( + pairsam_format.UNANNOTATED_RFRAG, + pairsam_format.UNMAPPED_POS, + pairsam_format.UNMAPPED_POS, + ) + + idx = min( + max(0, rsites_chrom.searchsorted(pos, "right") - 1), len(rsites_chrom) - 2 + ) + return idx, rsites_chrom[idx], rsites_chrom[idx + 1] diff --git a/pairtools/pairtools_stats.py b/pairtools/lib/stats.py old mode 100755 new mode 100644 similarity index 89% rename from pairtools/pairtools_stats.py rename to pairtools/lib/stats.py index 7328b177..20c4ab72 --- a/pairtools/pairtools_stats.py +++ b/pairtools/lib/stats.py @@ -1,87 +1,13 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import io -import sys -import click - import numpy as np -import pandas as pd - from collections.abc import Mapping - -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options - -UTIL_NAME = "pairtools_stats" - - -@cli.command() -@click.argument("input_path", type=str, nargs=-1, required=False) -@click.option("-o", "--output", type=str, default="", help="output stats tsv file.") -@click.option( - "--merge", - is_flag=True, - help="If specified, merge multiple input stats files instead of calculating" - " statistics of a .pairs/.pairsam file. Merging is performed via summation of" - " all overlapping statistics. Non-overlapping statistics are appended to" - " the end of the file.", -) -@common_io_options -def stats(input_path, output, merge, **kwargs): - """Calculate pairs statistics. - - INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. - If not provided, the input is read from stdin. - If --merge is specified, then INPUT_PATH is interpreted as an arbitrary number - of stats files to merge. - - The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. - """ - stats_py(input_path, output, merge, **kwargs) - - -def stats_py(input_path, output, merge, **kwargs): - if merge: - do_merge(output, input_path, **kwargs) - return - - instream = _fileio.auto_open( - input_path[0], - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - outstream = _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - header, body_stream = _headerops.get_header(instream) - cols = _headerops.extract_column_names(header) - - # new stats class stuff would come here ... - stats = PairCounter() - - # Collecting statistics - - for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): - stats.add_pairs_from_dataframe(chunk) - - # save statistics to file ... - stats.save(outstream) - - if instream != sys.stdin: - instream.close() - if outstream != sys.stdout: - outstream.close() - +import sys +from . import fileio def do_merge(output, files_to_merge, **kwargs): # Parse all stats files. stats = [] for stat_file in files_to_merge: - f = _fileio.auto_open( + f = fileio.auto_open( stat_file, mode="r", nproc=kwargs.get("nproc_in"), @@ -96,7 +22,7 @@ def do_merge(output, files_to_merge, **kwargs): out_stat = sum(stats) # Save merged stats. - outstream = _fileio.auto_open( + outstream = fileio.auto_open( output, mode="w", nproc=kwargs.get("nproc_out"), @@ -275,7 +201,7 @@ def from_file(cls, file_handle): continue if len(fields) != 2: # expect two _SEP separated values per line: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file".format(file_handle.name) ) # extract key and value, then split the key: @@ -287,7 +213,7 @@ def from_file(cls, file_handle): if key in stat_from_file._stat: stat_from_file._stat[key] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) @@ -302,7 +228,7 @@ def from_file(cls, file_handle): if len(key_fields) == 1: stat_from_file._stat[key][key_fields[0]] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 1 identifier".format( file_handle.name, key ) @@ -313,7 +239,7 @@ def from_file(cls, file_handle): if len(key_fields) == 2: stat_from_file._stat[key][tuple(key_fields)] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) @@ -342,13 +268,13 @@ def from_file(cls, file_handle): # store corresponding value: stat_from_file._stat[key][dirs][bin_idx] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) ) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) @@ -612,7 +538,3 @@ def save(self, outstream): # write flattened version of the PairCounter to outstream for k, v in self.flatten().items(): outstream.write("{}{}{}\n".format(k, self._SEP, v)) - - -if __name__ == "__main__": - stats() diff --git a/pairtools/pairtools_filterbycov.py b/pairtools/pairtools_filterbycov.py deleted file mode 100644 index a1f595d0..00000000 --- a/pairtools/pairtools_filterbycov.py +++ /dev/null @@ -1,621 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import sys -import ast -import warnings -import pathlib - -import click - -import numpy as np - -from . import _dedup, _fileio, _pairsam_format, _headerops, cli, common_io_options -from .pairtools_markasdup import mark_split_pair_as_dup -from .pairtools_stats import PairCounter - -UTIL_NAME = "pairtools_filterbycov" - -###################################### -## TODO: - output stats after filtering -## edit/update mark as dup to mark as multi -################################### - - -@cli.command() -@click.argument("pairs_path", type=str, required=False) -@click.option( - "-o", - "--output", - type=str, - default="", - help="output file for pairs from low coverage regions." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, the output is printed into stdout.", -) -@click.option( - "--output-highcov", - type=str, - default="", - help="output file for pairs from high coverage regions." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " If the path is the same as in --output or -, output duplicates together " - " with deduped pairs. By default, duplicates are dropped.", -) -@click.option( - "--output-unmapped", - type=str, - default="", - help="output file for unmapped pairs. " - "If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed. " - "If the path is the same as in --output or -, output unmapped pairs together " - "with deduped pairs. If the path is the same as --output-highcov, " - "output unmapped reads together. By default, unmapped pairs are dropped.", -) -@click.option( - "--output-stats", - type=str, - default="", - help="output file for statistics of multiple interactors. " - " If file exists, it will be open in the append mode." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, statistics are not printed.", -) -@click.option( - "--max-cov", type=int, default=8, help="The maximum allowed coverage per region." -) -@click.option( - "--max-dist", - type=int, - default=500, - help="The resolution for calculating coverage. For each pair, the local " - "coverage around each end is calculated as (1 + the number of neighbouring " - "pairs within +/- max_dist bp) ", -) -@click.option( - "--method", - type=click.Choice(["max", "sum"]), - default="max", - help="calculate the number of neighbouring pairs as either the sum or the max" - " of the number of neighbours on the two sides", - show_default=True, -) -@click.option( - "--sep", - type=str, - default=_pairsam_format.PAIRSAM_SEP_ESCAPE, - help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", -) -@click.option( - "--comment-char", type=str, default="#", help="The first character of comment lines" -) -@click.option( - "--send-header-to", - type=click.Choice(["lowcov", "highcov", "both", "none"]), - default="both", - help="Which of the outputs should receive header and comment lines", -) -@click.option( - "--c1", - type=int, - default=_pairsam_format.COL_C1, - help="Chrom 1 column; default {}".format(_pairsam_format.COL_C1), -) -@click.option( - "--c2", - type=int, - default=_pairsam_format.COL_C2, - help="Chrom 2 column; default {}".format(_pairsam_format.COL_C2), -) -@click.option( - "--p1", - type=int, - default=_pairsam_format.COL_P1, - help="Position 1 column; default {}".format(_pairsam_format.COL_P1), -) -@click.option( - "--p2", - type=int, - default=_pairsam_format.COL_P2, - help="Position 2 column; default {}".format(_pairsam_format.COL_P2), -) -@click.option( - "--s1", - type=int, - default=_pairsam_format.COL_S1, - help="Strand 1 column; default {}".format(_pairsam_format.COL_S1), -) -@click.option( - "--s2", - type=int, - default=_pairsam_format.COL_S2, - help="Strand 2 column; default {}".format(_pairsam_format.COL_S2), -) -@click.option( - "--unmapped-chrom", - type=str, - default=_pairsam_format.UNMAPPED_CHROM, - help="Placeholder for a chromosome on an unmapped side; default {}".format( - _pairsam_format.UNMAPPED_CHROM - ), -) -@click.option( - "--mark-multi", - is_flag=True, - help='If specified, duplicate pairs are marked as FF in "pair_type" and ' - "as a duplicate in the sam entries.", -) -@common_io_options -def filterbycov( - pairs_path, - output, - output_highcov, - output_unmapped, - output_stats, - max_dist, - max_cov, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_multi, - **kwargs -): - """Remove pairs from regions of high coverage. - - Find and remove pairs with >(MAX_COV-1) neighbouring pairs - within a +/- MAX_DIST bp window around either side. Useful for single-cell - Hi-C experiments, where coverage is naturally limited by the chromosome - copy number. - - PAIRS_PATH : input triu-flipped sorted .pairs or .pairsam file. If the - path ends with .gz/.lz4, the input is decompressed by bgzip/lz4c. - By default, the input is read from stdin. - """ - filterbycov_py( - pairs_path, - output, - output_highcov, - output_unmapped, - output_stats, - max_dist, - max_cov, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_multi, - **kwargs - ) - - -def filterbycov_py( - pairs_path, - output, - output_highcov, - output_unmapped, - output_stats, - max_dist, - max_cov, - method, - sep, - comment_char, - send_header_to, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - mark_multi, - **kwargs -): - - ## Prepare input, output streams based on selected outputs - ## Default ouput stream is low-frequency interactors - sep = ast.literal_eval('"""' + sep + '"""') - send_header_to_lowcov = send_header_to in ["both", "lowcov"] - send_header_to_highcov = send_header_to in ["both", "highcov"] - - instream = ( - _fileio.auto_open( - pairs_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - if pairs_path - else sys.stdin - ) - outstream = ( - _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout - ) - out_stats_stream = ( - _fileio.auto_open( - output_stats, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output_stats - else None - ) - - # generate empty PairCounter if stats output is requested: - out_stat = PairCounter() if output_stats else None - - # output the high-frequency interacting pairs - if not output_highcov: - outstream_high = None - elif output_highcov == "-" or ( - pathlib.Path(output_highcov).absolute() == pathlib.Path(output).absolute() - ): - outstream_high = outstream - else: - outstream_high = _fileio.auto_open( - output_highcov, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - # output unmapped pairs - if not output_unmapped: - outstream_unmapped = None - elif output_unmapped == "-" or ( - pathlib.Path(output_unmapped).absolute() == pathlib.Path(output).absolute() - ): - outstream_unmapped = outstream - elif ( - pathlib.Path(output_unmapped).absolute() - == pathlib.Path(output_highcov).absolute() - ): - outstream_unmapped = outstream_high - else: - outstream_unmapped = _fileio.auto_open( - output_unmapped, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - # prepare file headers - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - - # header for low-frequency interactors - if send_header_to_lowcov: - outstream.writelines((l + "\n" for l in header)) - - # header for high-frequency interactors - if send_header_to_highcov and outstream_high and (outstream_high != outstream): - outstream_high.writelines((l + "\n" for l in header)) - - # header for unmapped pairs - if ( - outstream_unmapped - and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_high) - ): - outstream_unmapped.writelines((l + "\n" for l in header)) - - # perform filtering of pairs based on low/high-frequency of interaction - streaming_filterbycov( - method, - max_dist, - max_cov, - sep, - c1, - c2, - p1, - p2, - s1, - s2, - unmapped_chrom, - body_stream, - outstream, - outstream_high, - outstream_unmapped, - out_stat, - mark_multi, - ) - - ## FINISHED! - # save statistics to a file if it was requested: TO BE TESTED - if out_stat: - out_stat.save(out_stats_stream) - - if instream != sys.stdin: - instream.close() - - if outstream != sys.stdout: - outstream.close() - - if outstream_high and (outstream_high != outstream): - outstream_high.close() - - if ( - outstream_unmapped - and (outstream_unmapped != outstream) - and (outstream_unmapped != outstream_high) - ): - outstream_unmapped.close() - - if out_stats_stream: - out_stats_stream.close() - - -def fetchadd(key, mydict): - key = key.strip() - if key not in mydict: - mydict[key] = len(mydict) - return mydict[key] - - -def ar(mylist, val): - return np.array(mylist, dtype={8: np.int8, 16: np.int16, 32: np.int32}[val]) - - -def _filterbycov(c1_in, p1_in, c2_in, p2_in, max_dist, method): - """ - This is a slow version of the filtering code used for testing purposes only - Use cythonized version in the future!! - """ - - c1 = np.asarray(c1_in, dtype=int) - p1 = np.asarray(p1_in, dtype=int) - c2 = np.asarray(c2_in, dtype=int) - p2 = np.asarray(p2_in, dtype=int) - - M = np.r_[ - np.c_[c1, p1], np.c_[c2, p2] - ] # M is a table of (chrom, pos) with 2*N rows - - assert c1.shape[0] == c2.shape[0] - N = 2 * c1.shape[0] - - ind_sorted = np.lexsort((M[:, 1], M[:, 0])) # sort by chromosomes, then positions - # M[ind_sorted] - # ind_sorted - # M, M[ind_sorted] - - if method == "sum": - proximity_count = np.zeros( - N - ) # keeps track of how many molecules each framgent end is close to - elif method == "max": - proximity_count = np.zeros(N) - else: - raise ValueError("Unknown method: {}".format(method)) - - low = 0 - high = 1 - while True: - - # boundary case finish - if low == N: - break - - # boundary case - CHECK - if high == N: - low += 1 - high = low + 1 - continue - - # check if "high" is proximal enough to "low" - - # first, if chromosomes not equal, we have gone too far, and the positions are not proximal - if M[ind_sorted[low], 0] != M[ind_sorted[high], 0]: - low += 1 - high = low + 1 # restart high - continue - - # next, if positions are not proximal, increase low, and continue - elif np.abs(M[ind_sorted[high], 1] - M[ind_sorted[low], 1]) > max_dist: - low += 1 - high = low + 1 # restart high - continue - - # if on the same chromosome, and the distance is "proximal enough", add to count of both "low" and "high" positions - else: - proximity_count[low] += 1 - proximity_count[high] += 1 - - high += 1 - - # unsort proximity count - # proximity_count = proximity_count[ind_sorted] - proximity_count[ind_sorted] = np.copy(proximity_count) - # print(M) - # print(proximity_count) - - # if method is sum of pairs - if method == "sum": - pcounts = proximity_count[0 : N // 2] + proximity_count[N // 2 :] + 1 - elif method == "max": - pcounts = np.maximum( - proximity_count[0 : N // 2] + 1, proximity_count[N // 2 :] + 1 - ) - else: - raise ValueError("Unknown method: {}".format(method)) - - return pcounts - - -def streaming_filterbycov( - method, - max_dist, - max_cov, - sep, - c1ind, - c2ind, - p1ind, - p2ind, - s1ind, - s2ind, - unmapped_chrom, - instream, - outstream, - outstream_high, - outstream_unmapped, - out_stat, - mark_multi, -): - - # doing everything in memory - maxind = max(c1ind, c2ind, p1ind, p2ind, s1ind, s2ind) - - # if we do stats in the dedup, we need PAIR_TYPE - # i do not see way around this: - if out_stat: - ptind = _pairsam_format.COL_PTYPE - maxind = max(maxind, ptind) - - c1 = [] - c2 = [] - p1 = [] - p2 = [] - s1 = [] - s2 = [] - line_buffer = [] - cols_buffer = [] - chromDict = {} - strandDict = {} - n_unmapped = 0 - n_high = 0 - n_low = 0 - - instream = iter(instream) - while True: - rawline = next(instream, None) - stripline = rawline.strip() if rawline else None - - # take care of empty lines not at the end of the file separately - if rawline and (not stripline): - warnings.warn("Empty line detected not at the end of the file") - continue - - if stripline: - cols = stripline.split(sep) - if len(cols) <= maxind: - raise ValueError( - "Error parsing line {}: ".format(stripline) - + " expected {} columns, got {}".format(maxind, len(cols)) - ) - - if (cols[c1ind] == unmapped_chrom) or (cols[c2ind] == unmapped_chrom): - - if outstream_unmapped: - outstream_unmapped.write(stripline) - # don't forget terminal newline - outstream_unmapped.write("\n") - - # add a pair to PairCounter if stats output is requested: - if out_stat: - out_stat.add_pair( - cols[c1ind], - int(cols[p1ind]), - cols[s1ind], - cols[c2ind], - int(cols[p2ind]), - cols[s2ind], - cols[ptind], - ) - else: - line_buffer.append(stripline) - cols_buffer.append(cols) - - c1.append(fetchadd(cols[c1ind], chromDict)) - c2.append(fetchadd(cols[c2ind], chromDict)) - p1.append(int(cols[p1ind])) - p2.append(int(cols[p2ind])) - s1.append(fetchadd(cols[s1ind], strandDict)) - s2.append(fetchadd(cols[s2ind], strandDict)) - - else: # when everything is loaded in memory... - - res = _filterbycov(c1, p1, c2, p2, max_dist, method) - - for i in range(len(res)): - # not high-frequency interactor pairs: - if not res[i] > max_cov: - outstream.write(line_buffer[i]) - # don't forget terminal newline - outstream.write("\n") - if out_stat: - out_stat.add_pair( - cols_buffer[i][c1ind], - int(cols_buffer[i][p1ind]), - cols_buffer[i][s1ind], - cols_buffer[i][c2ind], - int(cols_buffer[i][p2ind]), - cols_buffer[i][s2ind], - cols_buffer[i][ptind], - ) - # high-frequency interactor pairs: - else: - if out_stat: - out_stat.add_pair( - cols_buffer[i][c1ind], - int(cols_buffer[i][p1ind]), - cols_buffer[i][s1ind], - cols_buffer[i][c2ind], - int(cols_buffer[i][p2ind]), - cols_buffer[i][s2ind], - "FF", - ) - if outstream_high: - outstream_high.write( - # FF-marked pair: - sep.join(mark_split_pair_as_dup(cols_buffer[i])) - if mark_multi - # pair as is: - else line_buffer[i] - ) - # don't forget terminal newline - outstream_high.write("\n") - - # flush buffers and perform necessary checks here: - c1 = [] - c2 = [] - p1 = [] - p2 = [] - s1 = [] - s2 = [] - line_buffer = line_buffer[len(res) :] - cols_buffer = cols_buffer[len(res) :] - if not stripline: - if len(line_buffer) != 0: - raise ValueError( - "{} lines left in the buffer, ".format(len(line_buffer)) - + "should be none;" - + "something went terribly wrong" - ) - break - - break - - -if __name__ == "__main__": - filterbycov() diff --git a/pairtools/pairtools_markasdup.py b/pairtools/pairtools_markasdup.py deleted file mode 100644 index 94b31b6c..00000000 --- a/pairtools/pairtools_markasdup.py +++ /dev/null @@ -1,109 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import sys -import pipes -import click - -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options - -UTIL_NAME = "pairtools_markasdup" - - -@cli.command() -@click.argument("pairsam_path", type=str, required=False) -@click.option( - "-o", - "--output", - type=str, - default="", - help="output .pairsam file." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, the output is printed into stdout.", -) -@common_io_options -def markasdup(pairsam_path, output, **kwargs): - """Tag pairs as duplicates. - - Change the type of all pairs inside a .pairs/.pairsam file to DD. If sam - entries are present, change the pair type in the Yt SAM tag to 'Yt:Z:DD'. - - PAIRSAM_PATH : input .pairs/.pairsam file. If the path ends with .gz, the - input is gzip-decompressed. By default, the input is read from stdin. - """ - markasdup_py(pairsam_path, output, **kwargs) - - -def markasdup_py(pairsam_path, output, **kwargs): - instream = _fileio.auto_open( - pairsam_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - outstream = _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - outstream.writelines((l + "\n" for l in header)) - - for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) - mark_split_pair_as_dup(cols) - - outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) - outstream.write("\n") - - if instream != sys.stdin: - instream.close() - if outstream != sys.stdout: - outstream.close() - - -def mark_split_pair_as_dup(cols): - # if the original columns ended with a new line, the marked columns - # should as well. - original_has_newline = cols[-1].endswith("\n") - - cols[_pairsam_format.COL_PTYPE] = "DD" - - if (len(cols) > _pairsam_format.COL_SAM1) and ( - len(cols) > _pairsam_format.COL_SAM2 - ): - for i in (_pairsam_format.COL_SAM1, _pairsam_format.COL_SAM2): - - # split each sam column into sam entries, tag and assemble back - cols[i] = _pairsam_format.INTER_SAM_SEP.join( - [ - mark_sam_as_dup(sam) - for sam in cols[i].split(_pairsam_format.INTER_SAM_SEP) - ] - ) - - if original_has_newline and not cols[-1].endswith("\n"): - cols[-1] = cols[-1] + "\n" - return cols - - -def mark_sam_as_dup(sam): - """Tag the binary flag and the optional pair type field of a sam entry - as a PCR duplicate.""" - samcols = sam.split(_pairsam_format.SAM_SEP) - - if len(samcols) == 1: - return sam - - samcols[1] = str(int(samcols[1]) | 1024) - - for j in range(11, len(samcols)): - if samcols[j].startswith("Yt:Z:"): - samcols[j] = "Yt:Z:DD" - return _pairsam_format.SAM_SEP.join(samcols) - - -if __name__ == "__main__": - markasdup() diff --git a/setup.py b/setup.py index 51f3a1c6..5ddcd743 100644 --- a/setup.py +++ b/setup.py @@ -27,6 +27,7 @@ Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 + Programming Language :: Python :: 3.10 """ @@ -55,12 +56,12 @@ def get_version(): def get_ext_modules(): ext = ".pyx" if HAVE_CYTHON else ".c" src_files = glob.glob( - os.path.join(os.path.dirname(__file__), "pairtools", "*" + ext) + os.path.join(os.path.dirname(__file__), "pairtools", "lib", "*" + ext) ) ext_modules = [] for src_file in src_files: - name = "pairtools." + os.path.splitext(os.path.basename(src_file))[0] + name = "pairtools.lib." + os.path.splitext(os.path.basename(src_file))[0] if not "pysam" in name: ext_modules.append(Extension(name, [src_file])) else: @@ -110,7 +111,7 @@ def run(self): setup( name="pairtools", author="Open2C", - author_email="goloborodko.anton@gmail.com", + author_email="open.chromosome.collective@gmail.com", version=get_version(), license="MIT", description="CLI tools to process mapped Hi-C data", @@ -126,8 +127,8 @@ def run(self): python_requires=">=3.7", entry_points={ "console_scripts": [ - "pairtools = pairtools:cli", - #'pairsamtools = pairtools:cli', + "pairtools = pairtools.cli:cli", + #'pairsamtools = pairtools.cli:cli', ] }, packages=find_packages(), diff --git a/tests/test_headerops.py b/tests/test_headerops.py index 9b3d9ba7..673d38dc 100644 --- a/tests/test_headerops.py +++ b/tests/test_headerops.py @@ -1,17 +1,17 @@ # -*- coding: utf-8 -*- -from pairtools import _headerops +from pairtools.lib import headerops from nose.tools import assert_raises, with_setup, raises def test_make_standard_header(): - header = _headerops.make_standard_pairsheader() + header = headerops.make_standard_pairsheader() assert any([l.startswith("## pairs format") for l in header]) assert any([l.startswith("#shape") for l in header]) assert any([l.startswith("#columns") for l in header]) - header = _headerops.make_standard_pairsheader( + header = headerops.make_standard_pairsheader( chromsizes=[("b", 100), ("c", 100), ("a", 100)] ) @@ -19,7 +19,7 @@ def test_make_standard_header(): def test_samheaderops(): - header = _headerops.make_standard_pairsheader() + header = headerops.make_standard_pairsheader() samheader = [ "@SQ\tSN:chr1\tLN:100", "@SQ\tSN:chr2\tLN:100", @@ -27,14 +27,14 @@ def test_samheaderops(): "@PG\tID:bwa\tPN:bwa\tCL:bwa", "@PG\tID:bwa-2\tPN:bwa\tCL:bwa\tPP:bwa", ] - header_with_sam = _headerops.insert_samheader(header, samheader) + header_with_sam = headerops.insert_samheader(header, samheader) assert len(header_with_sam) == len(header) + len(samheader) for l in samheader: assert any([l2.startswith("#samheader") and l in l2 for l2 in header_with_sam]) # test adding new programs to the PG chain - header_extra_pg = _headerops.append_new_pg(header_with_sam, ID="test", PN="test") + header_extra_pg = headerops.append_new_pg(header_with_sam, ID="test", PN="test") # test if all lines got transferred assert all([(old_l in header_extra_pg) for old_l in header_with_sam]) @@ -58,25 +58,25 @@ def test_samheaderops(): def test_merge_pairheaders(): headers = [["## pairs format v1.0"], ["## pairs format v1.0"]] - merged_header = _headerops._merge_pairheaders(headers) + merged_header = headerops._merge_pairheaders(headers) assert merged_header == headers[0] headers = [["## pairs format v1.0", "#a"], ["## pairs format v1.0", "#b"]] - merged_header = _headerops._merge_pairheaders(headers) + merged_header = headerops._merge_pairheaders(headers) assert merged_header == ["## pairs format v1.0", "#a", "#b"] headers = [ ["## pairs format v1.0", "#chromsize: chr1 100", "#chromsize: chr2 200"], ["## pairs format v1.0", "#chromsize: chr1 100", "#chromsize: chr2 200"], ] - merged_header = _headerops._merge_pairheaders(headers) + merged_header = headerops._merge_pairheaders(headers) assert merged_header == headers[0] @raises(Exception) def test_merge_different_pairheaders(): headers = [["## pairs format v1.0"], ["## pairs format v1.1"]] - merged_header = _headerops._merge_pairheaders(headers) + merged_header = headerops._merge_pairheaders(headers) def test_force_merge_pairheaders(): @@ -84,7 +84,7 @@ def test_force_merge_pairheaders(): ["## pairs format v1.0", "#chromsize: chr1 100"], ["## pairs format v1.0", "#chromsize: chr2 200"], ] - merged_header = _headerops._merge_pairheaders(headers, force=True) + merged_header = headerops._merge_pairheaders(headers, force=True) assert merged_header == [ "## pairs format v1.0", "#chromsize: chr1 100", @@ -97,7 +97,7 @@ def test_merge_samheaders(): ["@HD\tVN:1"], ["@HD\tVN:1"], ] - merged_header = _headerops._merge_samheaders(headers) + merged_header = headerops._merge_samheaders(headers) assert merged_header == headers[0] headers = [ @@ -112,7 +112,7 @@ def test_merge_samheaders(): "@SQ\tSN:chr2\tLN:100", ], ] - merged_header = _headerops._merge_samheaders(headers) + merged_header = headerops._merge_samheaders(headers) assert merged_header == headers[0] headers = [ @@ -125,7 +125,7 @@ def test_merge_samheaders(): "@PG\tID:bwa\tPN:bwa\tPP:cat", ], ] - merged_header = _headerops._merge_samheaders(headers) + merged_header = headerops._merge_samheaders(headers) print(merged_header) assert merged_header == [ "@HD\tVN:1", @@ -144,5 +144,5 @@ def test_merge_headers(): ] ] * 2 - merged_header = _headerops.merge_headers(headers) + merged_header = headerops.merge_headers(headers) assert merged_header == headers[0] From 12a4bf605cf768f0b5b06e50244ddc8f0178009b Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 12 Apr 2022 10:40:30 -0400 Subject: [PATCH 09/52] Merge pairlib into pairtools.lib. --- .gitignore | 1 - examples/scalings_example.ipynb | 214 +++++++++++++++++++ pairtools/lib/regions.pyx | 46 ++++ pairtools/lib/scalings.py | 368 ++++++++++++++++++++++++++++++++ setup.py | 7 +- 5 files changed, 634 insertions(+), 2 deletions(-) create mode 100644 examples/scalings_example.ipynb create mode 100644 pairtools/lib/regions.pyx create mode 100644 pairtools/lib/scalings.py diff --git a/.gitignore b/.gitignore index 1d48b694..310c23a9 100644 --- a/.gitignore +++ b/.gitignore @@ -18,7 +18,6 @@ dist/ downloads/ eggs/ .eggs/ -lib/ lib64/ parts/ sdist/ diff --git a/examples/scalings_example.ipynb b/examples/scalings_example.ipynb new file mode 100644 index 00000000..d68d21a7 --- /dev/null +++ b/examples/scalings_example.ipynb @@ -0,0 +1,214 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2022-04-12 10:00:02-- https://data.4dnucleome.org/files-processed/4DNFI3PUO824/@@download/4DNFI3PUO824.pairs.gz\n", + "Resolving data.4dnucleome.org (data.4dnucleome.org)... 34.225.43.243, 34.199.170.160\n", + "Connecting to data.4dnucleome.org (data.4dnucleome.org)|34.225.43.243|:443... connected.\n", + "HTTP request sent, awaiting response... 403 Forbidden\n", + "2022-04-12 10:00:02 ERROR 403: Forbidden.\n", + "\n" + ] + } + ], + "source": [ + "!wget https://data.4dnucleome.org/files-processed/4DNFI3PUO824/@@download/4DNFI3PUO824.pairs.gz -O ./tmp/MicroC.pairs.gz " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker \n", + "import matplotlib.gridspec \n", + "\n", + "%matplotlib inline\n", + "plt.style.use('seaborn-poster')\n", + "\n", + "import pairtools\n", + "import pairtools.lib.scalings as scalings\n", + "import bioframe" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "pairs_path = '../tmp/MicroC.pairs.gz'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mm10_chromsizes = bioframe.fetch_chromsizes('mm10', as_bed=True)\n", + "mm10_arms = mm10_chromsizes\n", + "\n", + "# hg38_chromsizes = bioframe.fetch_chromsizes('hg38', as_bed=True)\n", + "# hg38_cens = bioframe.fetch_centromeres('hg38')\n", + "# hg38_arms = bioframe.split(hg38_chromsizes, hg38_cens, cols_points=['chrom', 'mid'])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "cis_scalings, trans_levels = scalings.compute_scaling(\n", + " pairs_path,\n", + " regions=mm10_arms,\n", + " chromsizes=mm10_chromsizes,\n", + " dist_range=(10, 1000000000), \n", + " n_dist_bins=128,\n", + " chunksize=int(1e7),\n", + " cmd_in=\"gzip -dc \"\n", + " )\n", + "\n", + "# calculate average trans contact frequency _per directionality pair_\n", + "# convert from int to float64 to avoid overflow\n", + "avg_trans = (\n", + " trans_levels.n_pairs.astype('float64').sum() \n", + " / trans_levels.np_bp2.astype('float64').sum()\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,10))\n", + "gs = matplotlib.gridspec.GridSpec(2,1, height_ratios=[8, 1.5])\n", + "ax1 = fig.add_subplot(gs[0,0])\n", + "ax2 = fig.add_subplot(gs[1,0])\n", + "\n", + "strand_gb = cis_scalings.groupby(['strand1', 'strand2'])\n", + "for strands in ['+-', '-+', '++', '--']:\n", + " sc_strand = strand_gb.get_group(tuple(strands))\n", + " sc_agg = (sc_strand\n", + " .groupby(['min_dist','max_dist'])\n", + " .agg({'n_pairs':'sum', 'n_bp2':'sum'})\n", + " .reset_index())\n", + "\n", + " dist_bin_mids = np.sqrt(sc_agg.min_dist * sc_agg.max_dist)\n", + " pair_frequencies = sc_agg.n_pairs / sc_agg.n_bp2\n", + " mask = pair_frequencies>0\n", + " label = f'{strands[0]}{strands[1]}'\n", + "\n", + " ax1.loglog(\n", + " dist_bin_mids[mask],\n", + " pair_frequencies[mask],\n", + " label=label,\n", + " lw=2\n", + " )\n", + "\n", + " ax2.semilogx(\n", + " np.sqrt(dist_bin_mids.values[1:]*dist_bin_mids.values[:-1]),\n", + " np.diff(np.log10(pair_frequencies.values)) / np.diff(np.log10(dist_bin_mids.values)),\n", + " label=label\n", + " )\n", + " \n", + "ax1.axhline(avg_trans, ls='--', c='gray', label='average trans')\n", + "\n", + "plt.sca(ax1)\n", + "plt.gca().set_aspect(1.0)\n", + "plt.gca().xaxis.set_major_locator(matplotlib.ticker.LogLocator(base=10.0,numticks=20))\n", + "plt.gca().yaxis.set_major_locator(matplotlib.ticker.LogLocator(base=10.0,numticks=20))\n", + "plt.xlim(1e1,1e9)\n", + "# plt.ylim(avg_trans / 3, plt.ylim()[1])\n", + "\n", + "plt.grid(lw=0.5,color='gray')\n", + "plt.legend(loc=(1.1,0.4))\n", + "plt.ylabel('contact frequency, \\nHi-C molecule per bp pair')\n", + "plt.xlabel('distance, bp')\n", + "\n", + "plt.sca(ax2)\n", + "plt.xlim(1e1,1e9)\n", + "plt.ylim(-2,0.5)\n", + "plt.gca().set_aspect(1.0)\n", + "plt.ylabel('log-log slope') \n", + "plt.xlabel('distance, bp')\n", + "\n", + "plt.yticks(np.arange(-2,0.6,0.5))\n", + "plt.gca().xaxis.set_major_locator(matplotlib.ticker.LogLocator(base=10.0,numticks=20))\n", + "plt.grid(lw=0.5,color='gray')\n", + "\n", + "# fig.tight_layout()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10", + "language": "python", + "name": "python310" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pairtools/lib/regions.pyx b/pairtools/lib/regions.pyx new file mode 100644 index 00000000..22fa45ce --- /dev/null +++ b/pairtools/lib/regions.pyx @@ -0,0 +1,46 @@ +""" Moved from pairlib, library for fast regions assignment """ +from cython.operator cimport dereference, postincrement, postdecrement + +from cpython cimport array +import cython + +from libcpp.map cimport map +from libcpp.algorithm cimport lower_bound, upper_bound +from libcpp.string cimport string +from libcpp.vector cimport vector + +import numpy as np +cimport numpy as np + +cpdef np.ndarray assign_regs_c(np.ndarray chroms, np.ndarray pos, dict reg_dict): + assert len(chroms) == len(pos) + + cdef int n = len(chroms) + cdef np.ndarray[np.int64_t, ndim=2] result = -1 * np.ones((n, 3), dtype=np.int64) + cdef map[string, vector[int]] reg_map = reg_dict + + cdef map[string, vector[int]].iterator reg_map_it = reg_map.begin() + cdef map[string, vector[int]].iterator reg_map_end = reg_map.end() + + cdef vector[int].iterator lo_b, up_b + cdef int position, reg_boundary_idx + + # this can be parallelized with prange + for i in range(n): + reg_map_it = reg_map.find(chroms[i]) + if reg_map_it != reg_map_end: + position = pos[i] + up_b = upper_bound( + dereference(reg_map_it).second.begin(), + dereference(reg_map_it).second.end(), + position) + reg_boundary_idx = up_b - dereference(reg_map_it).second.begin() + + if reg_boundary_idx % 2 == 1: + lo_b = up_b + postdecrement(lo_b) + result[i, 0] = (reg_boundary_idx - 1) // 2 + result[i, 1] = dereference(lo_b) + result[i, 2] = dereference(up_b) + + return result \ No newline at end of file diff --git a/pairtools/lib/scalings.py b/pairtools/lib/scalings.py new file mode 100644 index 00000000..42743bd8 --- /dev/null +++ b/pairtools/lib/scalings.py @@ -0,0 +1,368 @@ +import numpy as np +import pandas as pd + +from .regions import assign_regs_c + + +def geomprog(factor, start=1): + yield start + while True: + start *= factor + yield start + + +def _geomrange(start, end, factor, endpoint): + prev = np.nan + for i in geomprog(factor, start): + x = int(round(i)) + + if x > end: + break + + if x == prev: + continue + + prev = x + yield x + + if endpoint and prev != end: + yield end + + +def geomrange(start, end, factor, endpoint=False): + return np.fromiter(_geomrange(start, end, factor, endpoint), dtype=int) + + +def geomspace(start, end, num=50, endpoint=True): + factor = (end / start) ** (1 / num) + return geomrange(start, end, factor, endpoint=endpoint) + + +def _to_float(arr_or_scalar): + if np.isscalar(arr_or_scalar): + return float(arr_or_scalar) + else: + return np.asarray(arr_or_scalar).astype(float) + + +def assign_regs(chroms, pos, regs): + gb_regs = regs.sort_values(['chrom', 'start', 'end']).groupby(['chrom']) + + regs_dict = { + chrom.encode() : regs_per_chrom[['start','end']].values.flatten().astype(np.int64) + for chrom, regs_per_chrom in gb_regs + } + + return assign_regs_c( + np.asarray(chroms).astype('bytes'), + np.asarray(pos), + regs_dict) + + +def cartesian_df_product(df1, df2, suffixes=['1','2']): + return pd.merge( + left=df1.assign(cartesian_product_dummy=1), + right=df2.assign(cartesian_product_dummy=1), + on=['cartesian_product_dummy'], + how='outer', + suffixes=suffixes + ).drop('cartesian_product_dummy', axis='columns') + + +def make_empty_scaling(regions, dist_bins, multiindex=True): + + if dist_bins[0] != 0: + dist_bins = np.r_[0, dist_bins] + if dist_bins[-1] != np.iinfo(np.int64).max: + dist_bins = np.r_[dist_bins, np.iinfo(np.int64).max] + + strands_table = pd.DataFrame({'strand1':['+','+','-','-'],'strand2':['+','-','+','-']}) + dists_table = pd.DataFrame(list(zip(dist_bins[:-1],dist_bins[1:])), columns=['min_dist','max_dist']) + + out = regions.join(regions, on=None, lsuffix='1', rsuffix='2') + out = cartesian_df_product(out, strands_table) + out = cartesian_df_product(out, dists_table) + + if multiindex: + index_by = [ + 'chrom1', 'start1', 'end1', + 'chrom2', 'start2', 'end2', + 'strand1', 'strand2', + 'min_dist', 'max_dist'] + out.set_index(index_by, inplace=True) + + return out + + +def make_empty_cross_region_table(regions, drop_same_reg=True, split_by_strand=True, multiindex=True): + out = cartesian_df_product(regions, regions) + if split_by_strand: + strands_table = pd.DataFrame({'strand1':['+','+','-','-'],'strand2':['+','-','+','-']}) + out = cartesian_df_product(out, strands_table) + + if drop_same_reg: + out = out.query('(chrom1!=chrom2) or (start1!=start2) or (end1!=end2)') + + if multiindex: + index_by = ['chrom1', 'start1', 'end1', + 'chrom2', 'start2', 'end2'] + if split_by_strand: + index_by += ['strand1', 'strand2'] + + out.set_index(index_by, inplace=True) + + return out + + +def bins_pairs_by_distance( + pairs_df, + dist_bins, + regions=None, + chromsizes=None, + ignore_trans=False + ): + + if regions is None: + if chromsizes is None: + chroms = sorted(set.union( + set(pairs_df.chrom1.unique()), + set(pairs_df.chrom2.unique()))) + regions = pd.DataFrame({'chrom':chroms, 'start':0, 'end':-1}) + regions = regions[['chrom', 'start', 'end']] + + region_starts1, region_starts2 = 0, 0 + region_ends1, region_ends2 = -1, -1 + + else: + region_starts1, region_starts2 = 0, 0 + region_ends1 = pairs_df.chrom1.map(chromsizes).fillna(1).astype(np.int64) + region_ends2 = pairs_df.chrom2.map(chromsizes).fillna(1).astype(np.int64) + regions = pd.DataFrame([{'chrom':chrom, 'start':0, 'end':length} for chrom,length in chromsizes.items()]) + regions = regions[['chrom', 'start', 'end']] + + else: + _, region_starts1, region_ends1 = assign_regs( + pairs_df.chrom1.values, + pairs_df.pos1.values, + regions).T + _, region_starts2, region_ends2 = assign_regs( + pairs_df.chrom2.values, + pairs_df.pos2.values, + regions).T + + pairs_reduced_df = pd.DataFrame( + {'chrom1':pairs_df.chrom1.values, + 'start1':region_starts1, + 'end1':region_ends1, + 'chrom2':pairs_df.chrom2.values, + 'start2':region_starts2, + 'end2':region_ends2, + 'strand1':pairs_df.strand1.values, + 'strand2':pairs_df.strand2.values, + 'dist_bin_idx': np.searchsorted( + dist_bins, np.abs(pairs_df.pos1-pairs_df.pos2), side='right'), + 'n_pairs':1 + }, + copy=False) + + pairs_reduced_df['min_dist'] = np.where( + pairs_reduced_df['dist_bin_idx']>0, + dist_bins[pairs_reduced_df['dist_bin_idx']-1], + 0) + + pairs_reduced_df['max_dist'] = np.where( + pairs_reduced_df['dist_bin_idx'] norm_range[0]) + & (bin_mids < norm_range[1])]) + + return norm_cfreqs diff --git a/setup.py b/setup.py index 5ddcd743..6ae0480c 100644 --- a/setup.py +++ b/setup.py @@ -62,8 +62,13 @@ def get_ext_modules(): ext_modules = [] for src_file in src_files: name = "pairtools.lib." + os.path.splitext(os.path.basename(src_file))[0] - if not "pysam" in name: + if not "pysam" in name and not "regions" in name: ext_modules.append(Extension(name, [src_file])) + elif "regions" in name: + ext_modules.append(Extension( + name, [src_file], + language="c++", + )) else: import pysam From 1a8469bde563fe824c2f3434cac8c001c2b6d030 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 12 Apr 2022 10:42:22 -0400 Subject: [PATCH 10/52] scalings bugfix --- pairtools/lib/scalings.py | 434 +++++++++++++++++++++----------------- 1 file changed, 237 insertions(+), 197 deletions(-) diff --git a/pairtools/lib/scalings.py b/pairtools/lib/scalings.py index 42743bd8..6b752c8e 100644 --- a/pairtools/lib/scalings.py +++ b/pairtools/lib/scalings.py @@ -10,25 +10,25 @@ def geomprog(factor, start=1): start *= factor yield start - + def _geomrange(start, end, factor, endpoint): prev = np.nan for i in geomprog(factor, start): x = int(round(i)) - + if x > end: break if x == prev: continue - + prev = x yield x if endpoint and prev != end: yield end - + def geomrange(start, end, factor, endpoint=False): return np.fromiter(_geomrange(start, end, factor, endpoint), dtype=int) @@ -44,139 +44,155 @@ def _to_float(arr_or_scalar): else: return np.asarray(arr_or_scalar).astype(float) - + def assign_regs(chroms, pos, regs): - gb_regs = regs.sort_values(['chrom', 'start', 'end']).groupby(['chrom']) - + gb_regs = regs.sort_values(["chrom", "start", "end"]).groupby(["chrom"]) + regs_dict = { - chrom.encode() : regs_per_chrom[['start','end']].values.flatten().astype(np.int64) + chrom.encode(): regs_per_chrom[["start", "end"]] + .values.flatten() + .astype(np.int64) for chrom, regs_per_chrom in gb_regs } - - return assign_regs_c( - np.asarray(chroms).astype('bytes'), - np.asarray(pos), - regs_dict) - - -def cartesian_df_product(df1, df2, suffixes=['1','2']): + + return assign_regs_c(np.asarray(chroms).astype("bytes"), np.asarray(pos), regs_dict) + + +def cartesian_df_product(df1, df2, suffixes=["1", "2"]): return pd.merge( left=df1.assign(cartesian_product_dummy=1), - right=df2.assign(cartesian_product_dummy=1), - on=['cartesian_product_dummy'], - how='outer', - suffixes=suffixes - ).drop('cartesian_product_dummy', axis='columns') + right=df2.assign(cartesian_product_dummy=1), + on=["cartesian_product_dummy"], + how="outer", + suffixes=suffixes, + ).drop("cartesian_product_dummy", axis="columns") def make_empty_scaling(regions, dist_bins, multiindex=True): - + if dist_bins[0] != 0: dist_bins = np.r_[0, dist_bins] if dist_bins[-1] != np.iinfo(np.int64).max: dist_bins = np.r_[dist_bins, np.iinfo(np.int64).max] - - strands_table = pd.DataFrame({'strand1':['+','+','-','-'],'strand2':['+','-','+','-']}) - dists_table = pd.DataFrame(list(zip(dist_bins[:-1],dist_bins[1:])), columns=['min_dist','max_dist']) - - out = regions.join(regions, on=None, lsuffix='1', rsuffix='2') + + strands_table = pd.DataFrame( + {"strand1": ["+", "+", "-", "-"], "strand2": ["+", "-", "+", "-"]} + ) + dists_table = pd.DataFrame( + list(zip(dist_bins[:-1], dist_bins[1:])), columns=["min_dist", "max_dist"] + ) + + out = regions.join(regions, on=None, lsuffix="1", rsuffix="2") out = cartesian_df_product(out, strands_table) out = cartesian_df_product(out, dists_table) - + if multiindex: index_by = [ - 'chrom1', 'start1', 'end1', - 'chrom2', 'start2', 'end2', - 'strand1', 'strand2', - 'min_dist', 'max_dist'] + "chrom1", + "start1", + "end1", + "chrom2", + "start2", + "end2", + "strand1", + "strand2", + "min_dist", + "max_dist", + ] out.set_index(index_by, inplace=True) - + return out -def make_empty_cross_region_table(regions, drop_same_reg=True, split_by_strand=True, multiindex=True): +def make_empty_cross_region_table( + regions, drop_same_reg=True, split_by_strand=True, multiindex=True +): out = cartesian_df_product(regions, regions) - if split_by_strand: - strands_table = pd.DataFrame({'strand1':['+','+','-','-'],'strand2':['+','-','+','-']}) + if split_by_strand: + strands_table = pd.DataFrame( + {"strand1": ["+", "+", "-", "-"], "strand2": ["+", "-", "+", "-"]} + ) out = cartesian_df_product(out, strands_table) - + if drop_same_reg: - out = out.query('(chrom1!=chrom2) or (start1!=start2) or (end1!=end2)') - + out = out.query("(chrom1!=chrom2) or (start1!=start2) or (end1!=end2)") + if multiindex: - index_by = ['chrom1', 'start1', 'end1', - 'chrom2', 'start2', 'end2'] + index_by = ["chrom1", "start1", "end1", "chrom2", "start2", "end2"] if split_by_strand: - index_by += ['strand1', 'strand2'] - + index_by += ["strand1", "strand2"] + out.set_index(index_by, inplace=True) - + return out def bins_pairs_by_distance( - pairs_df, - dist_bins, - regions=None, - chromsizes=None, - ignore_trans=False - ): - + pairs_df, dist_bins, regions=None, chromsizes=None, ignore_trans=False +): + if regions is None: if chromsizes is None: - chroms = sorted(set.union( - set(pairs_df.chrom1.unique()), - set(pairs_df.chrom2.unique()))) - regions = pd.DataFrame({'chrom':chroms, 'start':0, 'end':-1}) - regions = regions[['chrom', 'start', 'end']] - + chroms = sorted( + set.union(set(pairs_df.chrom1.unique()), set(pairs_df.chrom2.unique())) + ) + regions = pd.DataFrame({"chrom": chroms, "start": 0, "end": -1}) + regions = regions[["chrom", "start", "end"]] + region_starts1, region_starts2 = 0, 0 region_ends1, region_ends2 = -1, -1 - + else: region_starts1, region_starts2 = 0, 0 region_ends1 = pairs_df.chrom1.map(chromsizes).fillna(1).astype(np.int64) region_ends2 = pairs_df.chrom2.map(chromsizes).fillna(1).astype(np.int64) - regions = pd.DataFrame([{'chrom':chrom, 'start':0, 'end':length} for chrom,length in chromsizes.items()]) - regions = regions[['chrom', 'start', 'end']] - + regions = pd.DataFrame( + [ + {"chrom": chrom, "start": 0, "end": length} + for chrom, length in chromsizes.items() + ] + ) + regions = regions[["chrom", "start", "end"]] + else: _, region_starts1, region_ends1 = assign_regs( - pairs_df.chrom1.values, - pairs_df.pos1.values, - regions).T + pairs_df.chrom1.values, pairs_df.pos1.values, regions + ).T _, region_starts2, region_ends2 = assign_regs( - pairs_df.chrom2.values, - pairs_df.pos2.values, - regions).T - + pairs_df.chrom2.values, pairs_df.pos2.values, regions + ).T + pairs_reduced_df = pd.DataFrame( - {'chrom1':pairs_df.chrom1.values, - 'start1':region_starts1, - 'end1':region_ends1, - 'chrom2':pairs_df.chrom2.values, - 'start2':region_starts2, - 'end2':region_ends2, - 'strand1':pairs_df.strand1.values, - 'strand2':pairs_df.strand2.values, - 'dist_bin_idx': np.searchsorted( - dist_bins, np.abs(pairs_df.pos1-pairs_df.pos2), side='right'), - 'n_pairs':1 - }, - copy=False) - - pairs_reduced_df['min_dist'] = np.where( - pairs_reduced_df['dist_bin_idx']>0, - dist_bins[pairs_reduced_df['dist_bin_idx']-1], - 0) - - pairs_reduced_df['max_dist'] = np.where( - pairs_reduced_df['dist_bin_idx'] 0, + dist_bins[pairs_reduced_df["dist_bin_idx"] - 1], + 0, ) - # importantly, in the future, we may want to extend the function to plot scalings + pairs_reduced_df["max_dist"] = np.where( + pairs_reduced_df["dist_bin_idx"] < len(dist_bins), + dist_bins[pairs_reduced_df["dist_bin_idx"]], + np.iinfo(np.int64).max, + ) + + # importantly, in the future, we may want to extend the function to plot scalings # for pairs from different regions! pairs_for_scaling_mask = ( @@ -184,108 +200,130 @@ def bins_pairs_by_distance( & (pairs_reduced_df.start1 == pairs_reduced_df.start2) & (pairs_reduced_df.end1 == pairs_reduced_df.end2) ) - + pairs_for_scaling_df = pairs_reduced_df.loc[pairs_for_scaling_mask] - + pairs_for_scaling_counts = pairs_for_scaling_df.groupby( - by=['chrom1', 'start1', 'end1', - 'chrom2', 'start2', 'end2', - 'strand1', 'strand2', - 'min_dist', 'max_dist']).agg({'n_pairs':'sum'}) - - pairs_for_scaling_counts = make_empty_scaling(regions, dist_bins).assign(n_pairs=0).add(pairs_for_scaling_counts, fill_value=0) - pairs_for_scaling_counts['n_pairs'] = pairs_for_scaling_counts['n_pairs'].astype(np.int64) - + by=[ + "chrom1", + "start1", + "end1", + "chrom2", + "start2", + "end2", + "strand1", + "strand2", + "min_dist", + "max_dist", + ] + ).agg({"n_pairs": "sum"}) + + pairs_for_scaling_counts = ( + make_empty_scaling(regions, dist_bins) + .assign(n_pairs=0) + .add(pairs_for_scaling_counts, fill_value=0) + ) + pairs_for_scaling_counts["n_pairs"] = pairs_for_scaling_counts["n_pairs"].astype( + np.int64 + ) + if ignore_trans: pairs_no_scaling_counts = None - else: + else: pairs_no_scaling_df = pairs_reduced_df.loc[~pairs_for_scaling_mask] - + pairs_no_scaling_counts = pairs_no_scaling_df.groupby( - by=['chrom1', 'start1', 'end1', - 'chrom2', 'start2', 'end2', - 'strand1', 'strand2', - ]).agg({'n_pairs':'sum'}) - - pairs_no_scaling_counts = make_empty_cross_region_table(regions).assign(n_pairs=0).add(pairs_no_scaling_counts, fill_value=0) - pairs_no_scaling_counts['n_pairs'] = pairs_no_scaling_counts['n_pairs'].astype(np.int64) - + by=[ + "chrom1", + "start1", + "end1", + "chrom2", + "start2", + "end2", + "strand1", + "strand2", + ] + ).agg({"n_pairs": "sum"}) + + pairs_no_scaling_counts = ( + make_empty_cross_region_table(regions) + .assign(n_pairs=0) + .add(pairs_no_scaling_counts, fill_value=0) + ) + pairs_no_scaling_counts["n_pairs"] = pairs_no_scaling_counts["n_pairs"].astype( + np.int64 + ) + return pairs_for_scaling_counts, pairs_no_scaling_counts -def contact_areas_same_reg( - min_dist, - max_dist, - region_length - ): - +def contact_areas_same_reg(min_dist, max_dist, region_length): + min_dist = _to_float(min_dist) max_dist = _to_float(max_dist) scaffold_length = _to_float(region_length) outer_areas = np.maximum(region_length - min_dist, 0) ** 2 inner_areas = np.maximum(region_length - max_dist, 0) ** 2 - return 0.5 * (outer_areas - inner_areas) + return 0.5 * (outer_areas - inner_areas) def _contact_areas_diff_reg( - min_dist, - max_dist, - region_start1, - region_end1, - region_start2, - region_end2 - ): - - return (contact_areas_same_reg(min_dist, max_dist, np.abs(region_end2 - region_start1)) - + contact_areas_same_reg(min_dist, max_dist, np.abs(region_end1 - region_start2)) - - contact_areas_same_reg(min_dist, max_dist, np.abs(region_start1 - region_start2)) - - contact_areas_same_reg(min_dist, max_dist, np.abs(region_end1 - region_end2)) - ) - - -def _contact_areas_trans( - min_dist, - max_dist, - region_length1, - region_length2 - ): - + min_dist, max_dist, region_start1, region_end1, region_start2, region_end2 +): + + return ( + contact_areas_same_reg(min_dist, max_dist, np.abs(region_end2 - region_start1)) + + contact_areas_same_reg( + min_dist, max_dist, np.abs(region_end1 - region_start2) + ) + - contact_areas_same_reg( + min_dist, max_dist, np.abs(region_start1 - region_start2) + ) + - contact_areas_same_reg(min_dist, max_dist, np.abs(region_end1 - region_end2)) + ) + + +def _contact_areas_trans(min_dist, max_dist, region_length1, region_length2): + return ( - contact_areas_same_reg(min_dist, max_dist, region_length1+region_length2) - -contact_areas_same_reg(min_dist, max_dist, region_length1) - -contact_areas_same_reg(min_dist, max_dist, region_length2) + contact_areas_same_reg(min_dist, max_dist, region_length1 + region_length2) + - contact_areas_same_reg(min_dist, max_dist, region_length1) + - contact_areas_same_reg(min_dist, max_dist, region_length2) ) def compute_scaling( - pairs, + pairs, regions=None, chromsizes=None, - dist_range=(int(1e1), int(1e9)), - n_dist_bins=8*8, + dist_range=(int(1e1), int(1e9)), + n_dist_bins=8 * 8, chunksize=int(1e7), ignore_trans=False, - filter_f = None, + filter_f=None, nproc_in=1, - cmd_in=None - ): + cmd_in=None, +): - dist_bins = geomspace(dist_range[0],dist_range[1],n_dist_bins) + dist_bins = geomspace(dist_range[0], dist_range[1], n_dist_bins) if isinstance(pairs, pd.DataFrame): pairs_df = pairs - - elif isinstance(pairs, str) or hasattr(pairs, 'buffer') or hasattr(pairs, 'peek'): + + elif isinstance(pairs, str) or hasattr(pairs, "buffer") or hasattr(pairs, "peek"): from . import fileio, headerops - pairs_stream = (fileio.auto_open(pairs, - mode="r", - nproc=nproc_in, - command=cmd_in, + pairs_stream = ( + fileio.auto_open( + pairs, + mode="r", + nproc=nproc_in, + command=cmd_in, ) if isinstance(pairs, str) - else pairs) - + else pairs + ) + header, pairs_body = headerops.get_header(pairs_stream) cols = headerops.extract_column_names(header) @@ -295,74 +333,76 @@ def compute_scaling( pairs_body, header=None, names=cols, - #nrows=1e6, + # nrows=1e6, chunksize=chunksize, - sep='\t', - dtype={'chrom1':str, 'chrom2':str} + sep="\t", + dtype={"chrom1": str, "chrom2": str}, ) else: - raise ValueError('pairs must be either a path to a pairs file or a pd.DataFrame') - + raise ValueError( + "pairs must be either a path to a pairs file or a pd.DataFrame" + ) sc, trans_counts = None, None - for pairs_chunk in ([pairs_df] if isinstance(pairs_df, pd.DataFrame) else pairs_df): + for pairs_chunk in [pairs_df] if isinstance(pairs_df, pd.DataFrame) else pairs_df: if filter_f: pairs_chunk = filter_f(pairs_chunk) sc_chunk, trans_counts_chunk = bins_pairs_by_distance( - pairs_chunk, + pairs_chunk, dist_bins, regions=regions, chromsizes=chromsizes, - ignore_trans=ignore_trans + ignore_trans=ignore_trans, + ) + + sc = sc_chunk if sc is None else sc.add(sc_chunk, fill_value=0) + trans_counts = ( + trans_counts_chunk + if trans_counts is None + else trans_counts.add(trans_counts_chunk, fill_value=0) ) - sc = (sc_chunk - if sc is None - else sc.add(sc_chunk, fill_value=0)) - trans_counts = (trans_counts_chunk - if trans_counts is None - else trans_counts.add(trans_counts_chunk, fill_value=0)) - -# if not (isinstance(regions, pd.DataFrame) and -# (set(regions.columns) == set(['chrom', 'start','end']))): -# raise ValueError('regions must be provided as a dict or chrom-indexed Series of chromsizes or as a bedframe.') - - sc.reset_index(inplace=True) - sc['n_bp2'] = contact_areas_same_reg( - sc['min_dist'], - sc['max_dist'], - sc['end1'] - sc['start1'] + # if not (isinstance(regions, pd.DataFrame) and + # (set(regions.columns) == set(['chrom', 'start','end']))): + # raise ValueError('regions must be provided as a dict or chrom-indexed Series of chromsizes or as a bedframe.') + + sc.reset_index(inplace=True) + sc["n_bp2"] = contact_areas_same_reg( + sc["min_dist"], sc["max_dist"], sc["end1"] - sc["start1"] ) - + if not ignore_trans: trans_counts.reset_index(inplace=True) - trans_counts['np_bp2'] = ( - (trans_counts['end1'] - trans_counts['start1']) - * (trans_counts['end2'] - trans_counts['start2']) + trans_counts["np_bp2"] = (trans_counts["end1"] - trans_counts["start1"]) * ( + trans_counts["end2"] - trans_counts["start2"] ) - + return sc, trans_counts -def norm_scaling_factor(bins, cfreqs, anchor=1.0, binwindow=(0,3)): +def norm_scaling_factor(bins, cfreqs, anchor=1.0, binwindow=(0, 3)): i = np.searchsorted(bins, anchor) - return cfreqs[i+binwindow[0]:i+binwindow[1]].mean() + return cfreqs[i + binwindow[0] : i + binwindow[1]].mean() -def norm_scaling(bins, cfreqs, anchor=1.0, binwindow=(0,3)): +def norm_scaling(bins, cfreqs, anchor=1.0, binwindow=(0, 3)): return cfreqs / norm_scaling_factor(bins, cfreqs, anchor, binwindow) def unity_norm_scaling(bins, cfreqs, norm_range=(1e4, 1e9)): - bins_lens = np.diff(bins) + bin_lens = np.diff(bins) bin_mids = np.sqrt(bins[1:] * bins[:-1]) if norm_range is None: - norm_cfreqs = cfreqs / np.sum(1. * (bin_lens * cfreqs)[np.isfinite(cfreqs)]) + norm_cfreqs = cfreqs / np.sum(1.0 * (bin_lens * cfreqs)[np.isfinite(cfreqs)]) else: - norm_cfreqs = cfreqs / np.sum(1. * (bin_lens * cfreqs)[ - np.isfinite(cfreqs) - & (bin_mids > norm_range[0]) - & (bin_mids < norm_range[1])]) + norm_cfreqs = cfreqs / np.sum( + 1.0 + * (bin_lens * cfreqs)[ + np.isfinite(cfreqs) + & (bin_mids > norm_range[0]) + & (bin_mids < norm_range[1]) + ] + ) return norm_cfreqs From 215c370d59f013865596baf9cdb84f2ebc1099d8 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 04:27:39 -0400 Subject: [PATCH 11/52] CLI for scalings added. --- .gitignore | 2 + examples/scalings_example.ipynb | 6 +- pairtools/cli/__init__.py | 1 + pairtools/cli/scaling.py | 106 ++++++++++++++++++++++ pairtools/cli/stats.py | 3 + pairtools/lib/{scalings.py => scaling.py} | 1 - 6 files changed, 115 insertions(+), 4 deletions(-) create mode 100644 pairtools/cli/scaling.py rename pairtools/lib/{scalings.py => scaling.py} (99%) diff --git a/.gitignore b/.gitignore index 310c23a9..cd90659d 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,8 @@ __pycache__/ # C extensions *.so +*.c +*.cpp # Distribution / packaging .Python diff --git a/examples/scalings_example.ipynb b/examples/scalings_example.ipynb index d68d21a7..1a0319b7 100644 --- a/examples/scalings_example.ipynb +++ b/examples/scalings_example.ipynb @@ -52,7 +52,7 @@ "plt.style.use('seaborn-poster')\n", "\n", "import pairtools\n", - "import pairtools.lib.scalings as scalings\n", + "import pairtools.lib.scaling as scaling\n", "import bioframe" ] }, @@ -85,7 +85,7 @@ "metadata": {}, "outputs": [], "source": [ - "cis_scalings, trans_levels = scalings.compute_scaling(\n", + "cis_scalings, trans_levels = scaling.compute_scaling(\n", " pairs_path,\n", " regions=mm10_arms,\n", " chromsizes=mm10_chromsizes,\n", @@ -206,7 +206,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/pairtools/cli/__init__.py b/pairtools/cli/__init__.py index 566ae0c0..095805d8 100644 --- a/pairtools/cli/__init__.py +++ b/pairtools/cli/__init__.py @@ -115,4 +115,5 @@ def wrapper(*args, **kwargs): stats, sample, filterbycov, + scaling ) diff --git a/pairtools/cli/scaling.py b/pairtools/cli/scaling.py new file mode 100644 index 00000000..c89142f3 --- /dev/null +++ b/pairtools/cli/scaling.py @@ -0,0 +1,106 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import io +import sys +import click +import pandas as pd + +from ..lib import fileio, pairsam_format, headerops +from . import cli, common_io_options + +from ..lib.scaling import compute_scaling + + +UTIL_NAME = "pairtools_scaling" + + +@cli.command() +@click.argument("input_path", type=str, nargs=-1, required=False) +@click.option("-o", "--output", type=str, default="", help="output .tsv file with summary.") +@click.option( + "--view", + "--regions", + help="Path to a BED file which defines which regions of the chromosomes to use. " + "By default, this is parsed from .pairs header. ", + type=str, + required=False, + default=None +) +@click.option( + "--chunksize", + type=int, + default=100_000, + show_default=True, + required=False, + help="Number of pairs in each chunk. Reduce for lower memory footprint.", +) +@click.option( + "--dist-range", + type=click.Tuple([int, int]), + default=(10, 1_000_000_000), + show_default=True, + required=False, + help="Distance range. ", +) +@click.option( + "--n-dist-bins", + type=int, + default=128, + show_default=True, + required=False, + help="Number of distance bins to split the distance range. ", +) +@common_io_options +def scaling(input_path, output, view, chunksize, dist_range, n_dist_bins, **kwargs): + """Calculate pairs scalings. + + INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. + If not provided, the input is read from stdin. + + The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. + + Output is .tsv file with scaling stats (both cis scalings and trans levels). + """ + scaling_py(input_path, output, view, chunksize, dist_range, n_dist_bins, **kwargs) + + +def scaling_py(input_path, output, view, chunksize, dist_range, n_dist_bins, **kwargs): + + if len(input_path) == 0: + raise ValueError(f"No input paths: {input_path}") + + instream = fileio.auto_open( + input_path[0], + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + outstream = fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + # Pass the header to the instream so that it can parse the header automatically + cis_scalings, trans_levels = compute_scaling( + instream, + regions=view, + chromsizes=None, + dist_range=dist_range, + n_dist_bins=n_dist_bins, + chunksize=chunksize, + ) + summary_stats = pd.concat([cis_scalings, trans_levels]) + + # save statistics to the file + summary_stats.to_csv(outstream, sep='\t') + + if instream != sys.stdin: + instream.close() + if outstream != sys.stdout: + outstream.close() + + +if __name__ == "__main__": + stats() diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index 19bd6f79..b54a47ba 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -44,6 +44,9 @@ def stats_py(input_path, output, merge, **kwargs): do_merge(output, input_path, **kwargs) return + if len(paths) == 0: + raise ValueError(f"No input paths: {pairs_path}") + instream = fileio.auto_open( input_path[0], mode="r", diff --git a/pairtools/lib/scalings.py b/pairtools/lib/scaling.py similarity index 99% rename from pairtools/lib/scalings.py rename to pairtools/lib/scaling.py index 6b752c8e..b3f1beb2 100644 --- a/pairtools/lib/scalings.py +++ b/pairtools/lib/scaling.py @@ -333,7 +333,6 @@ def compute_scaling( pairs_body, header=None, names=cols, - # nrows=1e6, chunksize=chunksize, sep="\t", dtype={"chrom1": str, "chrom2": str}, From bc53d1b3008eb75aa7475f85ba8d3bd28669378f Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 04:33:03 -0400 Subject: [PATCH 12/52] scaling tests --- pairtools/cli/scaling.py | 2 +- pairtools/cli/stats.py | 4 ++-- tests/test_scaling.py | 26 ++++++++++++++++++++++++++ 3 files changed, 29 insertions(+), 3 deletions(-) create mode 100644 tests/test_scaling.py diff --git a/pairtools/cli/scaling.py b/pairtools/cli/scaling.py index c89142f3..6034cced 100644 --- a/pairtools/cli/scaling.py +++ b/pairtools/cli/scaling.py @@ -103,4 +103,4 @@ def scaling_py(input_path, output, view, chunksize, dist_range, n_dist_bins, **k if __name__ == "__main__": - stats() + scaling() diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index b54a47ba..00f78a34 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -44,8 +44,8 @@ def stats_py(input_path, output, merge, **kwargs): do_merge(output, input_path, **kwargs) return - if len(paths) == 0: - raise ValueError(f"No input paths: {pairs_path}") + if len(input_path) == 0: + raise ValueError(f"No input paths: {input_path}") instream = fileio.auto_open( input_path[0], diff --git a/tests/test_scaling.py b/tests/test_scaling.py new file mode 100644 index 00000000..b795c96d --- /dev/null +++ b/tests/test_scaling.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +import os +import sys +import subprocess +from nose.tools import assert_raises +import pandas as pd +import io + +testdir = os.path.dirname(os.path.realpath(__file__)) + + +def test_scaling(): + mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") + try: + result = subprocess.check_output( + ["python", "-m", "pairtools", "scaling", mock_pairsam_path], + ).decode("ascii") + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + output = pd.read_csv(io.StringIO(result), sep='\t', header=0) + + # All the pairs, even "!" are counted as present because we don't provide regions + assert output["n_pairs"].sum()==8 From 4a11db60a633e11b6da80e5395bbf81cc4db2090 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 04:54:15 -0400 Subject: [PATCH 13/52] pairtools stats chromosome sizes --- pairtools/cli/stats.py | 13 +++++++++++++ pairtools/lib/stats.py | 15 +++++++++++++-- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index 00f78a34..a3fb78b4 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -25,6 +25,15 @@ " all overlapping statistics. Non-overlapping statistics are appended to" " the end of the file.", ) +@click.option( + "--with-chromsizes/--no-chromsizes", + is_flag=True, + default=True, + help="If specified, merge multiple input stats files instead of calculating" + " statistics of a .pairs/.pairsam file. Merging is performed via summation of" + " all overlapping statistics. Non-overlapping statistics are appended to" + " the end of the file.", +) @common_io_options def stats(input_path, output, merge, **kwargs): """Calculate pairs statistics. @@ -71,6 +80,10 @@ def stats_py(input_path, output, merge, **kwargs): for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): stats.add_pairs_from_dataframe(chunk) + if kwargs.get("with_chromsizes", True): + chromsizes = headerops.extract_chromsizes(header) + stats.add_chromsizes(chromsizes) + # save statistics to file ... stats.save(outstream) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 20c4ab72..d3947b16 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -417,6 +417,18 @@ def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): self._stat["cis_20kb+"] += int(np.sum(dist >= 20000)) self._stat["cis_40kb+"] += int(np.sum(dist >= 40000)) + def add_chromsizes(self, chromsizes): + """ Add chromsizes field to the output stats + + Parameters + ---------- + chromsizes: Dataframe with chromsizes, read by headerops.chromsizes + """ + + chromsizes = chromsizes.to_dict() + self._stat["chromsizes"] = chromsizes + return + def __add__(self, other): # both PairCounter are implied to have a list of common fields: # @@ -496,7 +508,7 @@ def flatten(self): ).format(k, self._dist_bins[i], dirs) # store key,value pair: flat_stat[formatted_key] = freqs[i] - elif (k in ["pair_types", "dedup"]) and v: + elif (k in ["pair_types", "dedup", "chromsizes"]) and v: # 'pair_types' and 'dedup' are simple dicts inside, # treat them the exact same way: for k_item, freq in v.items(): @@ -524,7 +536,6 @@ def save(self, outstream): ---------- outstream: file handle - Note ---- The order of the keys is not guaranteed From e946ef5f2fcf1969b6a07d07e021c0737b73a35a Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 05:30:02 -0400 Subject: [PATCH 14/52] stats output in yaml format --- examples/parse2_demo.ipynb | 1163 ------------------------------------ pairtools/cli/stats.py | 11 +- pairtools/lib/stats.py | 62 +- requirements.txt | 4 +- 4 files changed, 69 insertions(+), 1171 deletions(-) delete mode 100644 examples/parse2_demo.ipynb diff --git a/examples/parse2_demo.ipynb b/examples/parse2_demo.ipynb deleted file mode 100644 index 68efb4eb..00000000 --- a/examples/parse2_demo.ipynb +++ /dev/null @@ -1,1163 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/agalicina/anaconda3/envs/test/lib/python3.8/site-packages/proplot/config.py:1454: ProPlotWarning: Rebuilding font cache.\n" - ] - } - ], - "source": [ - "import proplot" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prepare the genome" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Activate bwa and minimap2 plugins for genomepy:\n", - "! genomepy plugins enable bwa\n", - "! genomepy plugins enable minimap2" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Install hg38 genome by genomepy:\n", - "! genomepy install hg38" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "hg38.blacklist.bed.gz hg38.fa.fai hg38.gaps.bed README.txt\r\n", - "hg38.fa\t\t hg38.fa.sizes index\r\n" - ] - } - ], - "source": [ - "# location of the genome:\n", - "! ls ~/.local/share/genomes/hg38/" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "^C\r\n" - ] - } - ], - "source": [ - "# Copy it to the local folder to simplify the code\n", - "! cp -r ~/.local/share/genomes/hg38 ./" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Digest the genome:\n", - "! cooler digest ./hg38/hg38.fa.sizes ./hg38/hg38.fa DpnII > ./hg38/hg38_DpnII.bed" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Long-read Arima example\n", - "\n", - "Comparison os parse and parse2 outputs on 150 bp reads.\n", - "\n", - "Example from [human cell line](https://www.ncbi.nlm.nih.gov/sra/SRX10230900[accn]): SRR13849430" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read 1000000 spots for SRR13849430\r\n", - "Written 1000000 spots for SRR13849430\r\n" - ] - } - ], - "source": [ - "# Download test data\n", - "! fastq-dump SRR13849430 --gzip --split-spot --split-3 --minSpotId 0 --maxSpotId 1000000" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[M::bwa_idx_load_from_disk] read 0 ALT contigs\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (3287, 41601, 3132, 3247)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1474, 3107, 5770)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14362)\n", - "[M::mem_pestat] mean and std.dev: (3761.23, 2688.41)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18658)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (223, 289, 356)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 622)\n", - "[M::mem_pestat] mean and std.dev: (277.40, 91.07)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 755)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1581, 3288, 5799)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14235)\n", - "[M::mem_pestat] mean and std.dev: (3826.54, 2661.54)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18453)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1390, 3033, 5607)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14041)\n", - "[M::mem_pestat] mean and std.dev: (3665.64, 2669.72)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18258)\n", - "[M::mem_process_seqs] Processed 333334 reads in 341.418 CPU sec, 93.551 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4098, 45623, 3818, 4052)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1387, 3097, 5547)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13867)\n", - "[M::mem_pestat] mean and std.dev: (3675.38, 2672.89)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18027)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (249, 315, 384)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 654)\n", - "[M::mem_pestat] mean and std.dev: (302.37, 92.23)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 789)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1521, 3113, 5702)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14064)\n", - "[M::mem_pestat] mean and std.dev: (3765.30, 2673.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18245)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1503, 3159, 5689)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14061)\n", - "[M::mem_pestat] mean and std.dev: (3747.58, 2673.34)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18247)\n", - "[M::mem_process_seqs] Processed 333334 reads in 343.883 CPU sec, 78.964 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4528, 42266, 4055, 4429)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1475, 3117, 5749)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14297)\n", - "[M::mem_pestat] mean and std.dev: (3758.22, 2705.83)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18571)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (256, 326, 400)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 688)\n", - "[M::mem_pestat] mean and std.dev: (310.02, 96.45)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 832)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1550, 3273, 5819)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14357)\n", - "[M::mem_pestat] mean and std.dev: (3856.53, 2696.57)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18626)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1487, 3090, 5637)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13937)\n", - "[M::mem_pestat] mean and std.dev: (3733.20, 2679.28)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18087)\n", - "[M::mem_process_seqs] Processed 333334 reads in 385.122 CPU sec, 87.424 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4076, 37876, 3820, 4047)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1454, 3061, 5610)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13922)\n", - "[M::mem_pestat] mean and std.dev: (3732.19, 2712.64)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18078)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (250, 320, 394)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 682)\n", - "[M::mem_pestat] mean and std.dev: (303.19, 95.64)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 826)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1571, 3307, 5902)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14564)\n", - "[M::mem_pestat] mean and std.dev: (3876.78, 2705.22)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18895)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1447, 3096, 5575)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13831)\n", - "[M::mem_pestat] mean and std.dev: (3720.16, 2684.08)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17959)\n", - "[M::mem_process_seqs] Processed 333334 reads in 455.097 CPU sec, 104.136 real sec\n", - "[M::process] read 333330 sequences (49999500 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4818, 38154, 4476, 4786)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1450, 3040, 5635)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14005)\n", - "[M::mem_pestat] mean and std.dev: (3690.60, 2666.10)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18190)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 341, 418)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 714)\n", - "[M::mem_pestat] mean and std.dev: (322.66, 97.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 862)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1559, 3229, 5848)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14426)\n", - "[M::mem_pestat] mean and std.dev: (3840.73, 2697.24)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18715)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1469, 3134, 5727)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14243)\n", - "[M::mem_pestat] mean and std.dev: (3761.26, 2703.10)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18501)\n", - "[M::mem_process_seqs] Processed 333334 reads in 354.385 CPU sec, 79.123 real sec\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4834, 38078, 4440, 4800)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1456, 3150, 5690)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14158)\n", - "[M::mem_pestat] mean and std.dev: (3764.15, 2683.53)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18392)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 342, 422)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 724)\n", - "[M::mem_pestat] mean and std.dev: (323.77, 98.63)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 875)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1653, 3328, 5869)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14301)\n", - "[M::mem_pestat] mean and std.dev: (3897.71, 2667.65)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18517)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1471, 3102, 5666)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14056)\n", - "[M::mem_pestat] mean and std.dev: (3732.45, 2677.73)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18251)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[M::mem_process_seqs] Processed 333330 reads in 326.313 CPU sec, 68.738 real sec\n", - "[main] Version: 0.7.17-r1188\n", - "[main] CMD: bwa mem -t 5 -SP /home/agalicina/.local/share/genomes//hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz\n", - "[main] Real time: 528.991 sec; CPU: 2212.054 sec\n" - ] - } - ], - "source": [ - "# Map test data:\n", - "! bwa mem -t 5 -SP ~/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz > test.bam" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run regular parse" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "pairtools parse -o test_arima_parse.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", - " --drop-sam --drop-seq --output-stats test_arima_parse.stats \\\n", - " --assembly hg38 --no-flip \\\n", - " --add-columns pos5,pos3 \\\n", - " --walks-policy mask \\\n", - " test.bam " - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SRR13849430.1\tchr12\t78795816\t!\t0\t-\t-\tUN\t78795816\t0\t78795720\t0\n", - "SRR13849430.2\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", - "SRR13849430.3\tchr2\t72005391\t!\t0\t+\t-\tUN\t72005391\t0\t72005521\t0\n", - "SRR13849430.4\tchr2\t20530788\t!\t0\t+\t-\tUN\t20530788\t0\t20530937\t0\n", - "SRR13849430.5\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", - "SRR13849430.6\tchr3\t857974\t!\t0\t+\t-\tUN\t857974\t0\t858099\t0\n", - "SRR13849430.7\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n", - "SRR13849430.8\tchr19\t40057590\t!\t0\t-\t-\tRN\t40057590\t0\t40057465\t0\n", - "SRR13849430.9\tchr6\t111954600\t!\t0\t-\t-\tRN\t111954600\t0\t111954451\t0\n", - "SRR13849430.10\t!\t0\t!\t0\t-\t-\tWW\t0\t0\t0\t0\n" - ] - } - ], - "source": [ - "%%bash\n", - "gzip -dc test_arima_parse.pairs.gz | grep -v \"#\" | head -n 10 | cat\n", - "# Note that there are now pos5 and pos3 columns:" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [], - "source": [ - "# Read the stats of regular parse:\n", - "stats_parse = pd.read_table('./test_arima_parse.stats', header=None)\n", - "stats_parse.columns = ['stat', 'count']\n", - "stats_parse.set_index('stat', inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 700 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if not 'freq' in x]\n", - "\n", - "plt.figure(figsize=[7, 5])\n", - "stats_parse.loc[columns, 'count'].plot(kind='bar')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run parse2" - ] - }, - { - "cell_type": "code", - "execution_count": 196, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Usage: pairtools parse2 [OPTIONS] [SAM_PATH]\n", - "\n", - " Find ligation junctions in .sam, make .pairs. SAM_PATH : an input\n", - " .sam/.bam file with paired-end sequence alignments of Hi-C molecules. If\n", - " the path ends with .bam, the input is decompressed from bam with samtools.\n", - " By default, the input is read from stdin.\n", - "\n", - "Options:\n", - " -c, --chroms-path TEXT Chromosome order used to flip\n", - " interchromosomal mates: path to a\n", - " chromosomes file (e.g. UCSC chrom.sizes or\n", - " similar) whose first column lists scaffold\n", - " names. Any scaffolds not listed will be\n", - " ordered lexicographically following the\n", - " names provided. [required]\n", - "\n", - " --assembly TEXT Name of genome assembly (e.g. hg19, mm10) to\n", - " store in the pairs header.\n", - "\n", - " --min-mapq INTEGER The minimal MAPQ score to consider a read as\n", - " uniquely mapped [default: 1]\n", - "\n", - " --max-inter-align-gap INTEGER read segments that are not covered by any\n", - " alignment and longer than the specified\n", - " value are treated as \"null\" alignments.\n", - " These null alignments convert otherwise\n", - " linear alignments into walks, and affect how\n", - " they get reported as a Hi-C pair. [default:\n", - " 20]\n", - "\n", - " --max-fragment-size INTEGER Largest fragment size for the detection of\n", - " overlapping alignments at the ends of\n", - " forward and reverse reads. Not used in\n", - " --single-end mode. [default: 500]\n", - "\n", - " --single-end If specified, the input is single-end.\n", - " -o, --output-file TEXT output file. If the path ends with .gz or\n", - " .lz4, the output is bgzip-/lz4-compressed.By\n", - " default, the output is printed into stdout.\n", - "\n", - " --coordinate-system [read|walk|pair]\n", - " coordinate system for reporting the walk.\n", - " \"read\" - orient each pair as it appeared on\n", - " a read, starting from 5'-end of forward then\n", - " reverse read. \"walk\" - orient each pair as\n", - " it appeared sequentially in the\n", - " reconstructed walk. \"pair\" - re-orient each\n", - " pair as if it was sequenced independently by\n", - " Hi-C. [default: read]\n", - "\n", - " --no-flip If specified, do not flip pairs in genomic\n", - " order and instead preserve the order in\n", - " which they were sequenced.\n", - "\n", - " --drop-readid If specified, do not add read ids to the\n", - " output\n", - "\n", - " --readid-transform TEXT A Python expression to modify read IDs.\n", - " Useful when read IDs differ between the two\n", - " reads of a pair. Must be a valid Python\n", - " expression that uses variables called readID\n", - " and/or i (the 0-based index of the read pair\n", - " in the bam file) and returns a new value,\n", - " e.g. \"readID[:-2]+'_'+str(i)\". Make sure\n", - " that transformed readIDs remain unique!\n", - "\n", - " --drop-seq If specified, remove sequences and PHREDs\n", - " from the sam fields\n", - "\n", - " --drop-sam If specified, do not add sams to the output\n", - " --add-junction-index If specified, parse2 will report junction\n", - " index for each pair in the walk\n", - "\n", - " --add-columns TEXT Report extra columns describing alignments\n", - " Possible values (can take multiple values as\n", - " a comma-separated list): a SAM tag (any pair\n", - " of uppercase letters) or mapq, pos5, pos3,\n", - " cigar, read_len, matched_bp, algn_ref_span,\n", - " algn_read_span, dist_to_5, dist_to_3, seq.\n", - "\n", - " --output-stats TEXT output file for various statistics of pairs\n", - " file. By default, statistics is not\n", - " generated.\n", - "\n", - " --nproc-in INTEGER Number of processes used by the auto-guessed\n", - " input decompressing command. [default: 3]\n", - "\n", - " --nproc-out INTEGER Number of processes used by the auto-guessed\n", - " output compressing command. [default: 8]\n", - "\n", - " --cmd-in TEXT A command to decompress the input file. If\n", - " provided, fully overrides the auto-guessed\n", - " command. Does not work with stdin. Must read\n", - " input from stdin and print output into\n", - " stdout. EXAMPLE: pbgzip -dc -n 3\n", - "\n", - " --cmd-out TEXT A command to compress the output file. If\n", - " provided, fully overrides the auto-guessed\n", - " command. Does not work with stdout. Must\n", - " read input from stdin and print output into\n", - " stdout. EXAMPLE: pbgzip -c -n 8\n", - "\n", - " -h, --help Show this message and exit.\n" - ] - } - ], - "source": [ - "%%bash\n", - "# Call for help:\n", - "pairtools parse2 -h" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "# Report pairs as if each one was sequenced independetly (coord system \"pair\")\n", - "pairtools parse2 -o test_arima_parse2.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", - " --drop-sam --drop-seq --output-stats test_arima_parse2.stats \\\n", - " --assembly hg38 --no-flip \\\n", - " --add-columns pos5,pos3 \\\n", - " --add-junction-index \\\n", - " --coordinate-system pair \\\n", - " test.bam" - ] - }, - { - "cell_type": "code", - "execution_count": 153, - "metadata": {}, - "outputs": [], - "source": [ - "stats_parse2 = pd.read_table('./test_arima_parse2.stats', header=None)\n", - "stats_parse2.columns = ['stat', 'count']\n", - "stats_parse2.set_index('stat', inplace=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "metadata": {}, - "outputs": [], - "source": [ - "stats_parse.loc[:, 'mode'] = 'arima_parse'\n", - "stats_parse2.loc[:, 'mode'] = 'arima_parse2'\n", - "stats_all = pd.concat([stats_parse, stats_parse2])" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if not 'freq' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", - "plt.xticks(rotation=90)\n", - "\n", - "plt.tight_layout()\n", - "# Note the artificial increase in the total number of pairs:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check P(s) for two regimes:" - ] - }, - { - "cell_type": "code", - "execution_count": 156, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '++' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 157, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '--' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 158, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '+-' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 159, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '-+' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='count', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ~~Restriction at the ends of alignments:~~\n", - "\n", - "tests to be implemented, for now only checks the restriction" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/agalicina/soft/pairtools2/pairtools/pairtools/pairtools_restrict.py:63: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n", - " rfrags = np.genfromtxt(\n" - ] - } - ], - "source": [ - "%%bash\n", - "# Select only UU and RU reads for parse and restrict:\n", - "pairtools select '(pair_type == \"UU\") or (pair_type == \"UR\") or (pair_type == \"RU\")' \\\n", - " -o test_arima_parse.UU.pairs.gz test_arima_parse.pairs.gz\n", - " \n", - "pairtools restrict -f ./hg38/hg38_DpnII.bed -o test_arima_parse.UU.restricted.pairs.gz test_arima_parse.UU.pairs.gz" - ] - }, - { - "cell_type": "code", - "execution_count": 129, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/agalicina/soft/pairtools2/pairtools/pairtools/pairtools_restrict.py:63: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n", - " rfrags = np.genfromtxt(\n" - ] - } - ], - "source": [ - "%%bash\n", - "# Select only UU reads for parse2 and restrict:\n", - "pairtools select '(pair_type == \"UU\")' \\\n", - " -o test_arima_parse2.UU.pairs.gz test_arima_parse2.pairs.gz\n", - " \n", - "pairtools restrict -f ./hg38/hg38_DpnII.bed -o test_arima_parse2.UU.restricted.pairs.gz test_arima_parse2.UU.pairs.gz" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## PacBio single-end example: MC-3C\n", - "\n", - "Single-end PacBio data from MC-3C [GSE146945](https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE146945):" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read 21359 spots for SRR11304457\r\n", - "Written 21359 spots for SRR11304457\r\n" - ] - } - ], - "source": [ - "%%bash\n", - "# Download test data\n", - "! fastq-dump SRR11304457 --minSpotId 0 --maxSpotId 1000000" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[M::main::9.122*0.99] loaded/built the index for 24 target sequence(s)\n", - "[M::mm_mapopt_update::10.979*1.00] mid_occ = 704\n", - "[M::mm_idx_stat] kmer size: 15; skip: 10; is_hpc: 0; #seq: 24\n", - "[M::mm_idx_stat::12.130*1.00] distinct minimizers: 100128525 (38.78% are singletons); average occurrences: 5.526; average spacing: 5.581; total length: 3088269832\n", - "[M::worker_pipeline::94.133*2.71] mapped 21359 sequences\n", - "[M::main] Version: 2.18-r1015\n", - "[M::main] CMD: minimap2 -a ./hg38/index/minimap2/hg38.mmi SRR11304457.fastq\n", - "[M::main] Real time: 94.654 sec; CPU: 255.252 sec; Peak RSS: 8.086 GB\n" - ] - } - ], - "source": [ - "%%bash\n", - "# Align with minimap2: \n", - "minimap2 -a ./hg38/index/minimap2/hg38.mmi SRR11304457.fastq > mc3c-test.sam" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "# Parse pairs\n", - "pairtools parse2 -o mc3c-test.pairs.gz -c ./hg38/hg38.fa.sizes \\\n", - " --drop-sam --drop-seq --output-stats mc3c-test_parse2.stats \\\n", - " --assembly hg38 --no-flip \\\n", - " --add-columns pos5,pos3 \\\n", - " --add-junction-index \\\n", - " --coordinate-system pair \\\n", - " --single-end \\\n", - " mc3c-test.sam" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Parse the stats table and compare with Arima. It two capture methods are inline with each other, this is a good sign:" - ] - }, - { - "cell_type": "code", - "execution_count": 176, - "metadata": {}, - "outputs": [], - "source": [ - "# Read the table\n", - "stats_mc3c = pd.read_table('./mc3c-test_parse2.stats', header=None)\n", - "stats_mc3c.columns = ['stat', 'count']\n", - "stats_mc3c.set_index('stat', inplace=True)\n", - "stats_mc3c.loc[:, 'mode'] = 'mc3c'" - ] - }, - { - "cell_type": "code", - "execution_count": 190, - "metadata": {}, - "outputs": [], - "source": [ - "# Columns with normalizaed data to make Arima and MC3C datasets comparable:\n", - "stats_mc3c.loc[:, 'norm_counts'] = 100*stats_mc3c['count']/stats_mc3c.loc['total_nodups', 'count']\n", - "stats_parse.loc[:, 'norm_counts'] = 100*stats_parse['count']/stats_parse.loc['total_nodups', 'count']\n", - "stats_parse2.loc[:, 'norm_counts'] = 100*stats_parse2['count']/stats_parse2.loc['total_nodups', 'count']" - ] - }, - { - "cell_type": "code", - "execution_count": 191, - "metadata": {}, - "outputs": [], - "source": [ - "stats_all = pd.concat([stats_parse, stats_parse2, stats_mc3c])" - ] - }, - { - "cell_type": "code", - "execution_count": 192, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if not 'freq' in x][5:]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='norm_counts', x='stat', hue='mode')\n", - "plt.xticks(rotation=90)\n", - "plt.title('Percentage of different types of pairs normalized to total nodups (%)')\n", - "plt.tight_layout()\n", - "\n", - "# Note increase in trans interactions for MC3C:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check P(s) for three regimes:" - ] - }, - { - "cell_type": "code", - "execution_count": 177, - "metadata": {}, - "outputs": [], - "source": [ - "stats_mc3c.loc[:, 'cis_norm_counts'] = 100*stats_mc3c['count']/stats_mc3c.loc['cis', 'count']\n", - "stats_parse.loc[:, 'cis_norm_counts'] = 100*stats_parse['count']/stats_parse.loc['cis', 'count']\n", - "stats_parse2.loc[:, 'cis_norm_counts'] = 100*stats_parse2['count']/stats_parse2.loc['cis', 'count']" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [], - "source": [ - "stats_all = pd.concat([stats_parse, stats_parse2, stats_mc3c])" - ] - }, - { - "cell_type": "code", - "execution_count": 186, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '++' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 187, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '--' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 188, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '+-' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 189, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 500, - "width": 900 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "columns = [x for x in stats_parse.index if 'dist_freq' in x and '-+' in x]\n", - "\n", - "plt.figure(figsize=[9, 5])\n", - "\n", - "sns.barplot(data=stats_all.loc[columns, :].reset_index(), y='cis_norm_counts', x='stat', hue='mode')\n", - "\n", - "plt.xticks(rotation=90)\n", - "plt.yscale('log')\n", - "plt.title('Percentage of different types of pairs normalized to cis (%)')\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## ~~Single-cell example~~\n", - "\n", - "~~snHi-C dat on K562 from Ilya Flyamer:~~\n", - "\n", - "To be implemented" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read 1000000 spots for SRR3344037\r\n", - "Written 1000000 spots for SRR3344037\r\n" - ] - } - ], - "source": [ - "# Download test data\n", - "! fastq-dump SRR3344037 --minSpotId 0 --maxSpotId 1000000" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index a3fb78b4..f1162805 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -34,6 +34,12 @@ " all overlapping statistics. Non-overlapping statistics are appended to" " the end of the file.", ) +@click.option( + "--yaml/--no-yaml", + is_flag=True, + default=False, + help="Output stats in yaml format instead of table. ", +) @common_io_options def stats(input_path, output, merge, **kwargs): """Calculate pairs statistics. @@ -75,8 +81,7 @@ def stats_py(input_path, output, merge, **kwargs): # new stats class stuff would come here ... stats = PairCounter() - # Collecting statistics - + # collecting statistics for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): stats.add_pairs_from_dataframe(chunk) @@ -85,7 +90,7 @@ def stats_py(input_path, output, merge, **kwargs): stats.add_chromsizes(chromsizes) # save statistics to file ... - stats.save(outstream) + stats.save(outstream, yaml=kwargs.get("yaml", False)) if instream != sys.stdin: instream.close() diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index d3947b16..b9ceb2de 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -474,7 +474,7 @@ def __add__(self, other): return sum_stat # we need this to be able to sum(list_of_PairCounters) - def __radd__(self, other): + def __read__(self, other): if other == 0: return self else: @@ -528,13 +528,62 @@ def flatten(self): # return flattened dict return flat_stat - def save(self, outstream): + def format(self): + """return a formatted dict (for the yaml output)""" + + from copy import deepcopy + + formatted_stat = {} + + # Storing statistics + for k, v in self._stat.items(): + if isinstance(v, int): + formatted_stat[k] = v + # store nested dicts/arrays in a context dependet manner: + # nested categories are stored only if they are non-trivial + else: + if (k == "dist_freq") and v: + freqs_dct = {} + + # iterate over distance bins: + for i in range(len(self._dist_bins)): + # iterate over all directions: + for dirs, freqs in v.items(): + # last bin is treated differently: "100000+" vs "1200-3000": + if i != len(self._dist_bins) - 1: + dist = "{}-{}".format(self._dist_bins[i], self._dist_bins[i + 1]) + else: + dist = "{}+".format(self._dist_bins[i]) + if dist not in freqs_dct.keys(): + freqs_dct[dist] = {} + + freqs_dct[dist][dirs] = int(freqs[i]) + + formatted_stat[k] = deepcopy(freqs_dct) + + elif (k in ["pair_types", "dedup", "chromsizes"]) and v: + # 'pair_types' and 'dedup' are simple dicts inside, + # treat them the exact same way: + formatted_stat[k] = deepcopy(v) + elif (k == "chrom_freq") and v: + freqs = {} + for (chrom1, chrom2), freq in v.items(): + freqs[self._KEY_SEP.join(["{}", "{}"]).format(chrom1, chrom2)] = freq + # store key,value pair: + formatted_stat[k] = deepcopy(freqs) + + # return flattened dict + return formatted_stat + + + def save(self, outstream, yaml=False): """save PairCounter to tab-delimited text file. Flattened version of PairCounter is stored in the file. Parameters ---------- outstream: file handle + yaml: is output in yaml format or table Note ---- @@ -547,5 +596,10 @@ def save(self, outstream): """ # write flattened version of the PairCounter to outstream - for k, v in self.flatten().items(): - outstream.write("{}{}{}\n".format(k, self._SEP, v)) + if yaml: + import yaml + data = self.format() + yaml.dump(data, outstream, default_flow_style=False) + else: + for k, v in self.flatten().items(): + outstream.write("{}{}{}\n".format(k, self._SEP, v)) diff --git a/requirements.txt b/requirements.txt index d4ced289..04d9deef 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,6 @@ nose>=1.3 click>=6.6 scipy>=1.7.0 pandas>=1.3.4 -pysam>=0.15.0 \ No newline at end of file +pysam>=0.15.0 +bioframe +yaml \ No newline at end of file From 0a809dab9d06a0138846236b49badec8f2935a2e Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 05:35:18 -0400 Subject: [PATCH 15/52] yaml dependency added to the workflows --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index f3dd7422..ab957606 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -52,7 +52,7 @@ jobs: conda info -a # Create test environment and install deps - conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy + conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy yaml source activate test-environment pip install click python setup.py build_ext -i From 4711f53b6fe754b4749465a37a9bbdb2f098daba Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 05:42:42 -0400 Subject: [PATCH 16/52] requirement update --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 04d9deef..53303de4 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,4 +6,4 @@ scipy>=1.7.0 pandas>=1.3.4 pysam>=0.15.0 bioframe -yaml \ No newline at end of file +pyyaml \ No newline at end of file From c97a3588b1f00c04067bb19c6e3888d5d2291932 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 05:58:31 -0400 Subject: [PATCH 17/52] Python 3.10 added to workflow --- .github/workflows/python-package.yml | 2 +- pairtools/lib/stats.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index ab957606..a7ab2801 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.7, 3.8, 3.9] + python-version: [3.7, 3.8, 3.9, 3.10] steps: - uses: actions/checkout@v2 diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index b9ceb2de..c42370c9 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -572,7 +572,7 @@ def format(self): # store key,value pair: formatted_stat[k] = deepcopy(freqs) - # return flattened dict + # return formatted dict return formatted_stat From e53b0ee8e61e7c60bb8b6da5dd7185b4a661069b Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 06:01:22 -0400 Subject: [PATCH 18/52] Python 3.10 fix --- .github/workflows/python-package.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index a7ab2801..f8caa6c5 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.7, 3.8, 3.9, 3.10] + python-version: ["3.7", "3.8", "3.9", "3.10"] steps: - uses: actions/checkout@v2 From cdee78d60528a230872f66250dd10c502aff574c Mon Sep 17 00:00:00 2001 From: agalitsyna Date: Thu, 14 Apr 2022 12:07:01 +0200 Subject: [PATCH 19/52] Header CLI (#121) - new module called by `pairtools header` - submodules: - generate : Generate the header - set-columns : Add the columns to the .pairs/pairsam file - transfer : Transfer the header from one pairs file to another - validate-columns : Validate the columns of the .pairs/pairsam file - resolves https://github.com/open2c/pairtools/issues/119 - option remove-columns for `pairtools select`: Remove the columns from .pairs/pairsam file --- pairtools/cli/__init__.py | 1 + pairtools/cli/header.py | 569 ++++++++++++++++++++++++++++++++ pairtools/cli/select.py | 51 ++- pairtools/lib/headerops.py | 114 ++++++- pairtools/lib/pairsam_format.py | 7 + tests/test_header.py | 48 +++ tests/test_select.py | 45 +++ 7 files changed, 821 insertions(+), 14 deletions(-) create mode 100644 pairtools/cli/header.py create mode 100644 tests/test_header.py diff --git a/pairtools/cli/__init__.py b/pairtools/cli/__init__.py index 095805d8..25a3f4f7 100644 --- a/pairtools/cli/__init__.py +++ b/pairtools/cli/__init__.py @@ -115,5 +115,6 @@ def wrapper(*args, **kwargs): stats, sample, filterbycov, + header, scaling ) diff --git a/pairtools/cli/header.py b/pairtools/cli/header.py new file mode 100644 index 00000000..63ec3392 --- /dev/null +++ b/pairtools/cli/header.py @@ -0,0 +1,569 @@ +import sys +import click +import warnings +import subprocess + +from ..lib import fileio, pairsam_format, headerops +from ..lib.parse_pysam import AlignmentFilePairtoolized +from . import cli, common_io_options + + +UTIL_NAME = "pairtools_header" + + +@cli.group() +def header(): + """ + Manipulate the .pairs/.pairsam header + """ + pass + + +# Common options for all header tools: +def register_subcommand(func): + return header.command()( + click.argument("pairs_path", type=str, required=False)( + click.option( + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", + )( + click.option( + "--nproc-in", + type=int, + default=1, + show_default=True, + help="Number of processes used by the auto-guessed input decompressing command.", + )( + click.option( + "--nproc-out", + type=int, + default=8, + show_default=True, + help="Number of processes used by the auto-guessed output compressing command.", + )( + click.option( + "--cmd-in", + type=str, + default=None, + help="A command to decompress the input. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdin. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -dc -n 3", + )( + click.option( + "--cmd-out", + type=str, + default=None, + help="A command to compress the output. " + "If provided, fully overrides the auto-guessed command. " + "Does not work with stdout. " + "Must read input from stdin and print output into stdout. " + "EXAMPLE: pbgzip -c -n 8", + )(func) + ) + ) + ) + ) + ) + ) + + +def add_arg_help(func): + func.__doc__ = func.__doc__.format( + """ + PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the + input is decompressed by bgzip/lz4c. By default, the input is read from stdin. + """ + ) + return func + + +@register_subcommand +@add_arg_help +@click.option( + "--chroms-path", + type=str, + default=None, + required=False, + help="Chromosome order used to flip interchromosomal mates: " + "path to a chromosomes file (e.g. UCSC chrom.sizes or similar) whose " + "first column lists scaffold names. Any scaffolds not listed will be " + "ordered lexicographically following the names provided.", +) +@click.option( + "--sam-path", + type=str, + default=None, + required=False, + help="Input sam file to inherit the header." + " Either --sam or --chroms-path should be provided to store the chromosome sizes in the header.", +) +@click.option( + "--columns", + type=click.STRING, + default="", + help="Report columns describing alignments " + "Can take multiple values as a comma-separated list." + f"By default, assign standard .pairs columns: {','.join(pairsam_format.COLUMNS)}", +) +@click.option( + "--extra-columns", + type=click.STRING, + default="", + help="Report extra columns describing alignments " + "Can take multiple values as a comma-separated list.", +) +@click.option( + "--assembly", + type=str, + default="", + help="Name of genome assembly (e.g. hg19, mm10) to store in the pairs header.", +) +@click.option( + "--no-flip", + is_flag=True, + help="If specified, assume that the pairs are not filpped in genomic order and instead preserve " + "the order in which they were sequenced.", +) +@click.option( + "--pairs/--pairsam", + is_flag=True, + default=True, + help=f"If pairs, then the defult columns will be set to: {','.join(pairsam_format.COLUMNS_PAIRS)}" + f"\nif pairsam, then to: {','.join(pairsam_format.COLUMNS_PAIRSAM)}", +) +def generate(pairs_path, output, chroms_path, sam_path, columns, assembly, **kwargs): + """ + Generate the header + + """ + generate_py(pairs_path, output, chroms_path, sam_path, columns, assembly, **kwargs) + + +def generate_py(pairs_path, output, chroms_path, sam_path, columns, assembly, **kwargs): + + instream = fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + header, body_stream = headerops.get_header(instream, ignore_warning=True) + + # Parse chromosome sizes present in the input chromosomes: + if chroms_path and not sam_path: + chromsizes = headerops.get_chromsizes_from_file(chroms_path) + # chromosomes = headerops.get_chromsizes_from_file(chroms_path) + + # Parse chromosome sizes present in sam input: + if sam_path: # open input sam file with pysam + input_sam = AlignmentFilePairtoolized( + sam_path, "r", threads=kwargs.get("nproc_in") + ) + samheader = input_sam.header + chromsizes = headerops.get_chromsizes_from_pysam_header(samheader) + # if chroms_path: + # chromosomes = headerops.get_chrom_order(chroms_path, list(chromsizes.keys())) + # else: + # chromosomes = chromsizes.keys() + + # Read the input columns: + if columns: + columns = columns.split(",") + else: + if kwargs.get("pairs", True): + columns = pairsam_format.COLUMNS_PAIRS + else: + columns = pairsam_format.COLUMNS_PAIRSAM + + extra_columns = kwargs.get("extra_columns", "") + if extra_columns: + columns += extra_columns.split(",") + + # Write new header to the pairsam file + new_header = headerops.make_standard_pairsheader( + assembly=assembly, + chromsizes=chromsizes, + columns=columns, + shape="whole matrix" if kwargs["no_flip"] else "upper triangle", + ) + + if sam_path: + new_header = headerops.insert_samheader_pysam(new_header, samheader) + + new_header = headerops.append_new_pg(new_header, ID=UTIL_NAME, PN=UTIL_NAME) + + # Check that the number of columns in the body corresponds to the header: + if not headerops.validate_cols(instream, columns): + raise ValueError( + f"Number of columns mismatch:\n\t#columns: {headerops.SEP_COLS.join(columns)}\n\t{body_stream.readline()}" + ) + + ######## + # Write the output after successful checks: + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + + outstream.writelines((l + "\n" for l in new_header)) + outstream.flush() + + if body_stream == sys.stdin: + for line in body_stream: + outstream.write(line) + else: + command = r""" + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat """ + + if kwargs.get("cmd_in", None): + command += r""" <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path, kwargs["cmd_in"] + ) + elif pairs_path.endswith(".gz"): + command += ( + r""" <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + kwargs["nproc_in"], pairs_path + ) + ) + elif pairs_path.endswith(".lz4"): + command += r""" <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path + ) + else: + command += r""" <(sed -n -e '\''/^[^#]/,$p'\'' {})""".format(pairs_path) + command += "'" + + subprocess.check_call(command, shell=True, stdout=outstream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + +@register_subcommand +@add_arg_help +@click.option( + "--reference-file", "-r", help="Header file for transfer", type=str, required=True +) +def transfer(pairs_path, output, reference_file, **kwargs): + """ + Transfer the header from one pairs file to another + + """ + transfer_py(pairs_path, output, reference_file, **kwargs) + + +def transfer_py(pairs_path, output, reference_file, **kwargs): + + instream = fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + header, body_stream = headerops.get_header(instream, ignore_warning=True) + + # Read the header from reference file + instream_header = fileio.auto_open( + reference_file, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + reference_header, _ = headerops.get_header(instream_header) + # Close the reference stream after extraction of the header: + if instream_header != sys.stdin: + instream_header.close() + + reference_columns = headerops.extract_column_names(reference_header) + + # Check that the number of columns in the body corresponds to the header: + if not headerops.validate_cols(instream, reference_columns): + raise ValueError( + f"Number of columns mismatch:\n\t#columns: {headerops.SEP_COLS.join(reference_columns)}\n\t{body_stream.readline()}" + ) + + ######## + # Write the output after successful checks: + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + + reference_header = headerops.append_new_pg( + reference_header, ID=UTIL_NAME, PN=UTIL_NAME + ) + outstream.writelines((l + "\n" for l in reference_header)) + outstream.flush() + + if body_stream == sys.stdin: + for line in body_stream: + outstream.write(line) + else: + command = r""" + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat """ + + if kwargs.get("cmd_in", None): + command += r""" <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path, kwargs["cmd_in"] + ) + elif pairs_path.endswith(".gz"): + command += ( + r""" <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + kwargs["nproc_in"], pairs_path + ) + ) + elif pairs_path.endswith(".lz4"): + command += r""" <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path + ) + else: + command += r""" <(sed -n -e '\''/^[^#]/,$p'\'' {})""".format(pairs_path) + command += "'" + + subprocess.check_call(command, shell=True, stdout=outstream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + +@register_subcommand +@add_arg_help +@click.option( + "--columns", + "-c", + help=f"Comma-separated list of columns to be added, e.g.: {','.join(pairsam_format.COLUMNS)}", + type=str, + required=True, +) +def set_columns(pairs_path, output, columns, **kwargs): + """ + Add the columns to the .pairs/pairsam file + """ + set_columns_py(pairs_path, output, columns, **kwargs) + + +def set_columns_py(pairs_path, output, columns, **kwargs): + instream = ( + fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + + header, body_stream = headerops.get_header(instream) + header = headerops.set_columns(header, columns.split(",")) + outstream.writelines((l + "\n" for l in header)) + outstream.flush() + + if body_stream == sys.stdin: + for line in body_stream: + outstream.write(line) + else: + command = r""" + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat """ + + if kwargs.get("cmd_in", None): + command += r""" <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path, kwargs["cmd_in"] + ) + elif pairs_path.endswith(".gz"): + command += ( + r""" <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + kwargs["nproc_in"], pairs_path + ) + ) + elif pairs_path.endswith(".lz4"): + command += r""" <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path + ) + else: + command += r""" <(sed -n -e '\''/^[^#]/,$p'\'' {})""".format(pairs_path) + command += "'" + + subprocess.check_call(command, shell=True, stdout=outstream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + +@register_subcommand +@add_arg_help +@click.option( + "--reference-file", + "-r", + help="Header file for comparison (optional)", + type=str, + required=False, + default="", +) +@click.option( + "--reference-columns", + "-c", + help=f"Comma-separated list of columns fro check (optional), e.g.: {','.join(pairsam_format.COLUMNS)}", + type=str, + required=False, + default="", +) +def validate_columns(pairs_path, output, reference_file, reference_columns, **kwargs): + """ + Validate the columns of the .pairs/pairsam file against reference or within file. + If the checks pass, then returns full pairs file. Otherwise throws an exception. + + If reference_file is provided, check: + 1) columns are the same between pairs and reference_file + 2) number of columns in the pairs body is the same as the number of columns + + If reference_columns are provided, check: + 1) pairs columns are the same as provided + 2) number of columns in the pairs body is the same as the number of columns + + If no reference_file or columns, then check only the number of columns in the pairs body. + Checks only the first line in the pairs stream! + + """ + validate_columns_py(pairs_path, output, reference_file, reference_columns, **kwargs) + + +def validate_columns_py( + pairs_path, output, reference_file, reference_columns, **kwargs +): + + instream = fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + header, body_stream = headerops.get_header(instream) + pairs_columns = headerops.extract_column_names(header) + + # Convert reference columns string into list, if provided + if reference_columns: + reference_columns = reference_columns.split(",") + + # Read the header from reference file + if reference_file: + instream_header = fileio.auto_open( + reference_file, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + reference_header, _ = headerops.get_header(instream_header) + # Close the reference stream after extraction of the header: + if instream_header != sys.stdin: + instream_header.close() + + if reference_columns: + warnings.warn( + "--reference-columns are ignored, as --reference-file is provided" + ) + + reference_columns = headerops.extract_column_names(reference_header) + + if reference_columns: + if pairs_columns != reference_columns: + raise ValueError( + f"Pairs columns differ from reference columns:\n\t{pairs_columns}\n\t{reference_columns}" + ) + + # Check that the number of columns in the body corresponds to the header: + if not headerops.validate_cols(instream, pairs_columns): + raise ValueError( + f"Number of columns mismatch:\n\t#columns: {headerops.SEP_COLS.join(pairs_columns)}\n\t{body_stream.readline()}" + ) + + ######## + # Write the output after successful checks: + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + outstream.writelines((l + "\n" for l in header)) + outstream.flush() + + if body_stream == sys.stdin: + for line in body_stream: + outstream.write(line) + else: + command = r""" + /bin/bash -c 'export LC_COLLATE=C; export LANG=C; cat """ + + if kwargs.get("cmd_in", None): + command += r""" <(cat {} | {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path, kwargs["cmd_in"] + ) + elif pairs_path.endswith(".gz"): + command += ( + r""" <(bgzip -dc -@ {} {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + kwargs["nproc_in"], pairs_path + ) + ) + elif pairs_path.endswith(".lz4"): + command += r""" <(lz4c -dc {} | sed -n -e '\''/^[^#]/,$p'\'')""".format( + pairs_path + ) + else: + command += r""" <(sed -n -e '\''/^[^#]/,$p'\'' {})""".format(pairs_path) + command += "'" + + subprocess.check_call(command, shell=True, stdout=outstream) + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + +if __name__ == "__main__": + header() diff --git a/pairtools/cli/select.py b/pairtools/cli/select.py index 31f610e7..e0d5723d 100644 --- a/pairtools/cli/select.py +++ b/pairtools/cli/select.py @@ -1,6 +1,7 @@ import sys import click import re, fnmatch +import warnings from ..lib import fileio, pairsam_format, headerops from . import cli, common_io_options @@ -65,6 +66,14 @@ "are cast to int, other columns are kept as str. Provide as " "-t , e.g. -t read_len1 int. Multiple entries are allowed.", ) +@click.option( + "--remove-columns", + "-r", + help=f"Comma-separated list of columns to be removed, e.g.: {','.join(pairsam_format.COLUMNS)}", + type=str, + default="", + required=False, +) @common_io_options def select( condition, @@ -74,6 +83,7 @@ def select( chrom_subset, startup_code, type_cast, + remove_columns, **kwargs ): """Select pairs according to some condition. @@ -121,6 +131,7 @@ def select( chrom_subset, startup_code, type_cast, + remove_columns, **kwargs ) @@ -133,6 +144,7 @@ def select_py( chrom_subset, startup_code, type_cast, + remove_columns, **kwargs ): @@ -192,7 +204,33 @@ def regex_match(x, regex): TYPES.update(dict(type_cast)) header, body_stream = headerops.get_header(instream) + + # Modify the header: header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + + # Filter out unwanted columns: + if remove_columns: + input_columns = headerops.extract_column_names(header) + remove_columns = remove_columns.split(",") + for col in remove_columns: + if col in pairsam_format.COLUMNS_PAIRS: + warnings.warn( + f"Removing required {col} column for .pairs format. Output is not .pairs anymore" + ) + elif col in pairsam_format.COLUMNS_PAIRSAM: + warnings.warn( + f"Removing required {col} column for .pairsam format. Output is not .pairsam anymore" + ) + updated_columns = [x for x in input_columns if x not in remove_columns] + + if len(updated_columns) == len(input_columns): + warnings.warn( + f"Some column(s) {','.join(remove_columns)} not in the file, the operation has no effect" + ) + else: + header = headerops.set_columns(header, updated_columns) + + # Update the chromosomes: if new_chroms is not None: header = headerops.subset_chroms_in_pairsheader(header, new_chroms) outstream.writelines((l + "\n" for l in header)) @@ -219,11 +257,22 @@ def regex_match(x, regex): else: condition = condition.replace(col, "COLS[{}]".format(i)) + # Compile the filtering expression: match_func = compile(condition, "", "eval") + # Columns filtration rule: + if remove_columns: + column_scheme = [input_columns.index(COL) for COL in updated_columns] + for line in body_stream: COLS = line.rstrip().split(pairsam_format.PAIRSAM_SEP) - if eval(match_func): + # Evaluate filtering expression: + filter_passed = eval(match_func) + if remove_columns: + COLS = [COLS[idx] for idx in column_scheme] # re-order the columns according to the scheme: + line = pairsam_format.PAIRSAM_SEP.join(COLS)+'\n' # form the line + + if filter_passed: outstream.write(line) elif outstream_rest: outstream_rest.write(line) diff --git a/pairtools/lib/headerops.py b/pairtools/lib/headerops.py index 7221a562..20b11d38 100644 --- a/pairtools/lib/headerops.py +++ b/pairtools/lib/headerops.py @@ -15,9 +15,22 @@ PAIRS_FORMAT_VERSION = "1.0.0" SEP_COLS = " " SEP_CHROMS = " " +COMMENT_CHAR = "#" +def get_stream_handlers(instream): + # get peekable buffer for the instream + readline_f, peek_f = None, None + if hasattr(instream, "buffer"): + peek_f = instream.buffer.peek + readline_f = instream.buffer.readline + elif hasattr(instream, "peek"): + peek_f = instream.peek + readline_f = instream.readline + else: + raise ValueError("Cannot find the peek() function of the provided stream!") + return readline_f, peek_f -def get_header(instream, comment_char="#"): +def get_header(instream, comment_char=COMMENT_CHAR, ignore_warning=False): """Returns a header from the stream and an the reaminder of the stream with the actual data. Parameters @@ -27,6 +40,8 @@ def get_header(instream, comment_char="#"): comment_char : str The character prepended to header lines (use '@' when parsing sams, '#' when parsing pairsams). + ignore_warning : bool + If True, then no warning will be generated if header of pairs file is empty. Returns ------- header : list @@ -39,17 +54,8 @@ def get_header(instream, comment_char="#"): if not comment_char: raise ValueError("Please, provide a comment char!") comment_byte = comment_char.encode() - # get peekable buffer for the instream - read_f, peek_f = None, None - if hasattr(instream, "buffer"): - peek_f = instream.buffer.peek - readline_f = instream.buffer.readline - elif hasattr(instream, "peek"): - peek_f = instream.peek - readline_f = instream.readline - else: - raise ValueError("Cannot find the peek() function of the provided stream!") + readline_f, peek_f = get_stream_handlers(instream) current_peek = peek_f(1) while current_peek.startswith(comment_byte): # consuming a line from buffer guarantees @@ -64,6 +70,10 @@ def get_header(instream, comment_char="#"): current_peek = peek_f(1) # apparently, next line does not start with the comment # return header and the instream, advanced to the beginning of the data + + if len(header)==0 and not ignore_warning: + warnings.warn("Headerless input, please, add the header by `pairtools header generate` or `pairtools header transfer`") + return header, instream @@ -77,7 +87,7 @@ def extract_fields(header, field_name, save_rest=False): fields = [] rest = [] for l in header: - if l.lstrip("#").startswith(field_name + ":"): + if l.lstrip(COMMENT_CHAR).startswith(field_name + ":"): fields.append(l.split(":", 1)[1].strip()) elif save_rest: rest.append(l) @@ -100,6 +110,52 @@ def extract_column_names(header): return [] +def validate_cols(stream, columns): + """ + Validate that the number of columns coincides between stream and columns. + Checks only the first line in the pairs stream! + + Note that it irreversibly removes the header from the stream. + + Parameters + ---------- + stream: input stream, body or full .pairs file + columns: columns to validate against + + Returns + ------- + True if the number of columns is identical between file and columns + """ + + comment_byte = COMMENT_CHAR.encode() + readline_f, peek_f = get_stream_handlers(stream) + + current_peek = peek_f(1) + while current_peek.startswith(comment_byte): + # consuming a line from buffer guarantees + # that the remainder of the buffer starts + # with the beginning of the line. + line = readline_f() + # peek into the remainder of the instream + current_peek = peek_f(1) + + line = readline_f() + if isinstance(line, bytes): + line = line.decode() + + ncols_body = len(line.split(pairsam_format.PAIRSAM_SEP)) + ncols_reference = len(columns) if isinstance(columns, list) else columns.split(SEP_COLS) + + return ncols_body==ncols_reference + + +def validate_header_cols(stream, header): + """ Validate that the number of columns corresponds between the stream and header """ + + columns = extract_column_names(header) + return validate_cols(stream, header) + + def extract_chromsizes(header): """ Extract chromosome sizes from header lines. @@ -131,6 +187,20 @@ def get_chromsizes_from_pysam_header(samheader): return dict(chromsizes) +def get_chromsizes_from_file(chroms_file): + """ + Produce an "enumeration" of chromosomes based on the list + of chromosomes + """ + chrom_sizes = dict() + with open(chroms_file, "rt") as f: + for line in f: + chrom, size = line.strip().split("\t") + chrom_sizes[chrom] = int(size) + + return chrom_sizes + + def get_chromsizes_from_pysam_header(samheader): """Convert pysam header to pairtools chromosomes (ordered dict). @@ -263,7 +333,7 @@ def _update_header_entry(header, field, new_value): found = False newline = "#{}: {}".format(field, new_value) for i in range(len(header)): - if header[i].startswith("#" + field): + if header[i].startswith(COMMENT_CHAR + field): header[i] = newline found = True if not found: @@ -662,6 +732,24 @@ def append_columns(header, columns): return header +def set_columns(header, columns): + """ + Set columns to the header, separated by SEP_COLS + + Parameters + ---------- + header: Previous header + columns: List of column names to append + + Returns + ------- + Modified header (appended columns to the field "#columns") + """ + for i in range(len(header)): + if header[i].startswith("#columns:"): + header[i] = "#columns:"+ SEP_COLS + SEP_COLS.join(columns) + return header + # def _guess_genome_assembly(samheader): # PG = [l for l in samheader if l.startswith('@PG') and '\tID:bwa' in l][0] # CL = [field for field in PG.split('\t') if field.startswith('CL:')] diff --git a/pairtools/lib/pairsam_format.py b/pairtools/lib/pairsam_format.py index 2cd14244..8be5e298 100644 --- a/pairtools/lib/pairsam_format.py +++ b/pairtools/lib/pairsam_format.py @@ -31,6 +31,13 @@ "pair_index", ] +# Required columns for formats: +COLUMNS_PAIRSAM = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', + 'strand1', 'strand2', 'pair_type', 'sam1', 'sam2'] + +COLUMNS_PAIRS = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', + 'strand1', 'strand2', 'pair_type'] + UNMAPPED_CHROM = "!" UNMAPPED_POS = 0 UNMAPPED_STRAND = "-" diff --git a/tests/test_header.py b/tests/test_header.py new file mode 100644 index 00000000..73e4b068 --- /dev/null +++ b/tests/test_header.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +import os +import sys + +from nose.tools import assert_raises + +import subprocess + +testdir = os.path.dirname(os.path.realpath(__file__)) + + +def test_generate(): + """Test generation of the header. + Example run: + pairtools header generate tests/data/mock.pairsam \ + --chroms-path tests/data/mock.chrom.sizes --pairsam \ + --sam-path tests/data/mock.sam + """ + + mock_sam_path = os.path.join(testdir, "data", "mock.sam") + mock_pairs_path = os.path.join(testdir, "data", "mock.pairsam") + mock_chroms_path = os.path.join(testdir, "data", "mock.chrom.sizes") + try: + result = subprocess.check_output( + [ + "python", + "-m", + "pairtools", + "header", + "generate", + "--chroms-path", + mock_chroms_path, + "--sam-path", + mock_sam_path, + "--pairsam", + mock_pairs_path, + ], + ).decode("ascii") + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check if the header got transferred correctly + sam_header = [l.strip() for l in open(mock_sam_path, "r") if l.startswith("@")] + pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")] + for l in sam_header: + assert any([l in l2 for l2 in pairsam_header]) diff --git a/tests/test_select.py b/tests/test_select.py index 24a2d040..33d09c2f 100644 --- a/tests/test_select.py +++ b/tests/test_select.py @@ -3,6 +3,7 @@ import sys import subprocess from nose.tools import assert_raises +from pairtools.lib import pairsam_format testdir = os.path.dirname(os.path.realpath(__file__)) mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") @@ -208,3 +209,47 @@ def test_chrom_subset(): ] assert set(chroms_from_chrom_sizes) == set(["chr1", "chr2"]) + + +def test_remove_columns(): + """Test removal of columns from the file + Example run: + pairtools select True --remove-columns sam1,sam2 tests/data/mock.pairsam + """ + + mock_pairs_path = os.path.join(testdir, "data", "mock.pairsam") + try: + result = subprocess.check_output( + [ + "python", + "-m", + "pairtools", + "select", + "True", + "--remove-columns", + "sam1,sam2", + mock_pairs_path, + ], + ).decode("ascii") + + except subprocess.CalledProcessError as e: + print(e.output) + print(sys.exc_info()) + raise e + + # check if the columns are removed properly: + pairsam_header = [l.strip() for l in result.split("\n") if l.startswith("#")] + for l in pairsam_header: + if l.startswith("#columns:"): + line = l.strip() + assert ( + line + == "#columns: readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type" + ) + + # check that the pairs got assigned properly + for l in result.split("\n"): + if l.startswith("#") or not l: + continue + + assert len(l.split(pairsam_format.PAIRSAM_SEP)) == 8 From 8a8a9fbb7f0b496311e3d81e623133004c441c78 Mon Sep 17 00:00:00 2001 From: agalitsyna Date: Thu, 14 Apr 2022 12:27:40 +0200 Subject: [PATCH 20/52] pairtools phase critical update (#114) * --tag-mode parameter: XA and XB modes for original and github versions of bwa * XB number of fields problem resolved * comparison of str to integer in alt scores resolved (did not work before!) * reporting scores of optimal, suboptimal and second suboptimal scores added (controlled by --report-scores) * explanations of the inner working added to the docs --- pairtools/cli/phase.py | 260 ++++++++++++++++--------- pairtools/lib/phase.py | 80 ++++++++ pairtools/pairtools_phase.py | 360 +++++++++++++++++++++++++++++++++++ 3 files changed, 614 insertions(+), 86 deletions(-) create mode 100644 pairtools/lib/phase.py create mode 100644 pairtools/pairtools_phase.py diff --git a/pairtools/cli/phase.py b/pairtools/cli/phase.py index 4cb6f10e..045c7203 100644 --- a/pairtools/cli/phase.py +++ b/pairtools/cli/phase.py @@ -5,8 +5,9 @@ from ..lib import fileio, pairsam_format, headerops from . import cli, common_io_options -UTIL_NAME = "pairtools_phase" +from ..lib.phase import phase_side_XB, phase_side_XA +UTIL_NAME = "pairtools_phase" @cli.command() @click.argument("pairs_path", type=str, required=False) @@ -23,43 +24,88 @@ "--phase-suffixes", nargs=2, # type=click.Tuple([str, str]), - help="phase suffixes.", + help="Phase suffixes (of the chrom names), always a pair.", ) @click.option( "--clean-output", is_flag=True, - help="drop all columns besides the standard ones and phase1/2", + help="Drop all columns besides the standard ones and phase1/2", +) +@click.option( + "--tag-mode", + type=click.Choice(["XB", "XA"]), + default="XB", + help="Specifies the mode of bwa reporting." + " XA will parse 'XA', the input should be generated with: --add-columns XA,NM,AS,XS --min-mapq 0" + " XB will parse 'XB' tag, the input should be generated with: --add-columns XB,AS,XS --min-mapq 0 " + " Note that XB tag is added by running bwa with -u tag, present in github version. " + " Both modes report similar results: XB reports 0.002% contacts more for phased data, " + " while XA can report ~1-2% more unphased contacts because its definition multiple mappers is more premissive. ", +) +@click.option( + "--report-scores/--no-report-scores", + is_flag=True, + default=False, + help="Report scores of optional, suboptimal and second suboptimal alignments. " + "NM (edit distance) with --tag-mode XA and AS (alfn score) with --tag-mode XB ", ) @common_io_options -def phase(pairs_path, output, phase_suffixes, clean_output, **kwargs): +def phase(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): """Phase pairs mapped to a diploid genome. + Diploid genome is the genome with two set of the chromosome variants, + where each chromosome has one of two suffixes (phase-suffixes) + corresponding to the genome version (phase-suffixes). + + By default, phasing adds two additional columns with phase 0, 1 or "." (unpahsed). + + Phasing is based on detection of chromosome origin of each mapped fragment. + Three scores are considered: best alignment score (S1), + suboptimal alignment (S2) and second suboptimal alignment (S3) scores. + Each fragment can be: + 1) uniquely mapped and phased (S1>S2>S3, first alignment is the best hit), + 2) uniquely mapped but unphased (S1=S2>S3, cannot distinguish between chromosome variants), + 3) multiply mapped (S1=S2=S3) or unmapped. PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the input is decompressed by bgzip/lz4c. By default, the input is read from stdin. """ - phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs) + phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs) -def phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs): +if __name__ == "__main__": + phase() - instream = fileio.auto_open( - pairs_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), + +def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): + + instream = ( + fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin ) - outstream = fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), + outstream = ( + fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout ) header, body_stream = headerops.get_header(instream) header = headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) old_column_names = headerops.extract_column_names(header) + idx_phase1 = len(old_column_names) + idx_phase2 = len(old_column_names) + 1 if clean_output: new_column_names = [ col for col in old_column_names if col in pairsam_format.COLUMNS @@ -68,88 +114,116 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, **kwargs): i for i, col in enumerate(old_column_names) if col in pairsam_format.COLUMNS - ] + [len(old_column_names), len(old_column_names) + 1] + ] + new_column_idxs += [idx_phase1, idx_phase2] else: new_column_names = list(old_column_names) new_column_names.append("phase1") new_column_names.append("phase2") + + if report_scores: + if tag_mode=="XB": + new_column_names.append("S1_1") + new_column_names.append("S1_2") + new_column_names.append("S2_1") + new_column_names.append("S2_2") + new_column_names.append("S3_1") + new_column_names.append("S3_2") + if clean_output: + new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] + elif tag_mode=="XA": + new_column_names.append("M1_1") + new_column_names.append("M1_2") + new_column_names.append("M2_1") + new_column_names.append("M2_2") + new_column_names.append("M3_1") + new_column_names.append("M3_2") + if clean_output: + new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] header = headerops._update_header_entry( header, "columns", " ".join(new_column_names) ) - if ( - ("XB1" not in old_column_names) - or ("XB2" not in old_column_names) - or ("AS1" not in old_column_names) - or ("AS2" not in old_column_names) - or ("XS1" not in old_column_names) - or ("XS2" not in old_column_names) - ): - raise ValueError( - "The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0" - ) - - COL_XB1 = old_column_names.index("XB1") - COL_XB2 = old_column_names.index("XB2") - COL_AS1 = old_column_names.index("AS1") - COL_AS2 = old_column_names.index("AS2") - COL_XS1 = old_column_names.index("XS1") - COL_XS2 = old_column_names.index("XS2") - - outstream.writelines((l + "\n" for l in header)) + if tag_mode == "XB": + if ( + ("XB1" not in old_column_names) + or ("XB2" not in old_column_names) + or ("AS1" not in old_column_names) + or ("AS2" not in old_column_names) + or ("XS1" not in old_column_names) + or ("XS2" not in old_column_names) + ): + raise ValueError( + "The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0" + ) - def get_chrom_phase(chrom, phase_suffixes): - if chrom.endswith(phase_suffixes[0]): - return "0", chrom[: -len(phase_suffixes[0])] - elif chrom.endswith(phase_suffixes[1]): - return "1", chrom[: -len(phase_suffixes[1])] - else: - return "!", chrom - - def phase_side(chrom, XB, AS, XS, phase_suffixes): - phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) - XBs = [i for i in XB.split(";") if len(i) > 0] - - if AS > XS: - return phase, chrom_base - - elif len(XBs) >= 1: - if len(XBs) >= 2: - alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS = XBs[1].split(",") - if alt2_AS == XS == AS: - return "!", "!" - - alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS = XBs[0].split(",") - alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) - - alt_is_homologue = (chrom_base == alt_chrom_base) and ( - ((phase == "0") and (alt_phase == "1")) - or ((phase == "1") and (alt_phase == "0")) + COL_XB1 = old_column_names.index("XB1") + COL_XB2 = old_column_names.index("XB2") + COL_AS1 = old_column_names.index("AS1") + COL_AS2 = old_column_names.index("AS2") + COL_XS1 = old_column_names.index("XS1") + COL_XS2 = old_column_names.index("XS2") + + elif tag_mode == "XA": + if ( + ("XA1" not in old_column_names) + or ("XA2" not in old_column_names) + or ("NM1" not in old_column_names) + or ("NM2" not in old_column_names) + or ("AS1" not in old_column_names) + or ("AS2" not in old_column_names) + or ("XS1" not in old_column_names) + or ("XS2" not in old_column_names) + ): + raise ValueError( + "The input pairs file must be parsed with the flag --add-columns XA,NM,AS,XS --min-mapq 0" ) - if alt_is_homologue: - return ".", chrom_base + COL_XA1 = old_column_names.index("XA1") + COL_XA2 = old_column_names.index("XA2") + COL_NM1 = old_column_names.index("NM1") + COL_NM2 = old_column_names.index("NM2") + COL_AS1 = old_column_names.index("AS1") + COL_AS2 = old_column_names.index("AS2") + COL_XS1 = old_column_names.index("XS1") + COL_XS2 = old_column_names.index("XS2") - return "!", "!" + outstream.writelines((l + "\n" for l in header)) for line in body_stream: cols = line.rstrip().split(pairsam_format.PAIRSAM_SEP) cols.append("!") cols.append("!") + if report_scores: + for _ in range(6): + cols.append("!") pair_type = cols[pairsam_format.COL_PTYPE] if cols[pairsam_format.COL_C1] != pairsam_format.UNMAPPED_CHROM: - - phase1, chrom_base1 = phase_side( - cols[pairsam_format.COL_C1], - cols[COL_XB1], - int(cols[COL_AS1]), - int(cols[COL_XS1]), - phase_suffixes, - ) - - cols[-2] = phase1 + if tag_mode == "XB": + phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XB( + cols[pairsam_format.COL_C1], + cols[COL_XB1], + int(cols[COL_AS1]), + int(cols[COL_XS1]), + phase_suffixes, + ) + elif tag_mode == "XA": + phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XA( + cols[pairsam_format.COL_C1], + cols[COL_XA1], + int(cols[COL_AS1]), + int(cols[COL_XS1]), + int(cols[COL_NM1]), + phase_suffixes, + ) + + if not report_scores: + cols[idx_phase1] = phase1 + else: + cols[idx_phase1], cols[idx_phase1+2], cols[idx_phase1+4], cols[idx_phase1+6] \ + = phase1, str(S1_1), str(S2_1), str(S3_1) cols[pairsam_format.COL_C1] = chrom_base1 if chrom_base1 == "!": @@ -160,15 +234,29 @@ def phase_side(chrom, XB, AS, XS, phase_suffixes): if cols[pairsam_format.COL_C2] != pairsam_format.UNMAPPED_CHROM: - phase2, chrom_base2 = phase_side( - cols[pairsam_format.COL_C2], - cols[COL_XB2], - int(cols[COL_AS2]), - int(cols[COL_XS2]), - phase_suffixes, - ) - - cols[-1] = phase2 + if tag_mode == "XB": + phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XB( + cols[pairsam_format.COL_C2], + cols[COL_XB2], + int(cols[COL_AS2]), + int(cols[COL_XS2]), + phase_suffixes, + ) + elif tag_mode == "XA": + phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XA( + cols[pairsam_format.COL_C2], + cols[COL_XA2], + int(cols[COL_AS2]), + int(cols[COL_XS2]), + int(cols[COL_NM2]), + phase_suffixes, + ) + + if not report_scores: + cols[idx_phase1] = phase2 + else: + cols[idx_phase2], cols[idx_phase2+2], cols[idx_phase2+4], cols[idx_phase2+6] \ + = phase2, str(S1_2), str(S2_2), str(S3_2) cols[pairsam_format.COL_C2] = chrom_base2 if chrom_base2 == "!": diff --git a/pairtools/lib/phase.py b/pairtools/lib/phase.py new file mode 100644 index 00000000..e3aa3bcc --- /dev/null +++ b/pairtools/lib/phase.py @@ -0,0 +1,80 @@ +def get_chrom_phase(chrom, phase_suffixes): + if chrom.endswith(phase_suffixes[0]): + return "0", chrom[: -len(phase_suffixes[0])] + elif chrom.endswith(phase_suffixes[1]): + return "1", chrom[: -len(phase_suffixes[1])] + else: + return "!", chrom + + +def phase_side_XB(chrom, XB, AS, XS, phase_suffixes): + + phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) + + XBs = [i for i in XB.split(';') if len(i) > 0] + S1, S2, S3 = AS, XS, -1 # -1 if the second hit was not reported + + if AS > XS: # Primary hit has higher score than the secondary + return phase, chrom_base, S1, S2, S3 + + elif len(XBs) >= 1: + if len(XBs) >= 2: + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS, alt_mapq = XBs[1].split(',') + S3 = int(alt2_AS) + if int(alt2_AS) == XS == AS: + return '!', '!', S1, S2, S3 + + alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS, alt_mapq = XBs[0].split(',') + alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) + + alt_is_homologue = ( + (chrom_base == alt_chrom_base) + and + ( + ((phase == '0') and (alt_phase == '1')) + or + ((phase == '1') and (alt_phase == '0')) + ) + ) + + if alt_is_homologue: + return '.', chrom_base, S1, S2, S3 + + return '!', '!', S1, S2, S3 + + +def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): + + phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) + + XAs = [i for i in XA.split(";") if len(i.strip()) > 0] + if len(XAs) >= 1: + alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") + M1, M2, M3 = NM, int(alt_NM), -1 + else: + M1, M2, M3 = NM, -1, -1 # -1 if the second hit was not reported + + if (AS > XS): # Primary hit has higher score than the secondary + return phase, chrom_base, M1, M2, M3 + + elif len(XAs) >= 1: + + if len(XAs) >= 2: + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM = XAs[1].split(",") + M3 = int(alt2_NM) + if int(alt2_NM) == int(alt_NM) == NM: + return "!", "!", M1, M2, M3 + + alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") + + alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) + + alt_is_homologue = (chrom_base == alt_chrom_base) and ( + ((phase == "0") and (alt_phase == "1")) + or ((phase == "1") and (alt_phase == "0")) + ) + + if alt_is_homologue: + return ".", chrom_base, M1, M2, M3 + + return "!", "!", M1, M2, M3 \ No newline at end of file diff --git a/pairtools/pairtools_phase.py b/pairtools/pairtools_phase.py new file mode 100644 index 00000000..05698103 --- /dev/null +++ b/pairtools/pairtools_phase.py @@ -0,0 +1,360 @@ +import sys +import click +import re, fnmatch + +from . import _fileio, _pairsam_format, cli, _headerops, common_io_options + +UTIL_NAME = "pairtools_phase" + + +@cli.command() +@click.argument("pairs_path", type=str, required=False) +@click.option( + "-o", + "--output", + type=str, + default="", + help="output file." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, the output is printed into stdout.", +) +@click.option( + "--phase-suffixes", + nargs=2, + # type=click.Tuple([str, str]), + help="Phase suffixes (of the chrom names), always a pair.", +) +@click.option( + "--clean-output", + is_flag=True, + help="Drop all columns besides the standard ones and phase1/2", +) +@click.option( + "--tag-mode", + type=click.Choice(["XB", "XA"]), + default="XB", + help="Specifies the mode of bwa reporting." + " XA will parse 'XA', the input should be generated with: --add-columns XA,NM,AS,XS --min-mapq 0" + " XB will parse 'XB' tag, the input should be generated with: --add-columns XB,AS,XS --min-mapq 0 " + " Note that XB tag is added by running bwa with -u tag, present in github version. " + " Both modes report similar results: XB reports 0.002% contacts more for phased data, " + " while XA can report ~1-2% more unphased contacts because its definition multiple mappers is more premissive. ", +) +@click.option( + "--report-scores/--no-report-scores", + is_flag=True, + default=False, + help="Report scores of optional, suboptimal and second suboptimal alignments. " + "NM (edit distance) with --tag-mode XA and AS (alfn score) with --tag-mode XB ", +) +@common_io_options +def phase(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): + """Phase pairs mapped to a diploid genome. + Diploid genome is the genome with two set of the chromosome variants, + where each chromosome has one of two suffixes (phase-suffixes) + corresponding to the genome version (phase-suffixes). + + By default, phasing adds two additional columns with phase 0, 1 or "." (unpahsed). + + Phasing is based on detection of chromosome origin of each mapped fragment. + Three scores are considered: best alignment score (S1), + suboptimal alignment (S2) and second suboptimal alignment (S3) scores. + Each fragment can be: + 1) uniquely mapped and phased (S1>S2>S3, first alignment is the best hit), + 2) uniquely mapped but unphased (S1=S2>S3, cannot distinguish between chromosome variants), + 3) multiply mapped (S1=S2=S3) or unmapped. + + PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the + input is decompressed by bgzip/lz4c. By default, the input is read from stdin. + + """ + phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs) + + +if __name__ == "__main__": + phase() + + +def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): + + instream = ( + _fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + if pairs_path + else sys.stdin + ) + outstream = ( + _fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + if output + else sys.stdout + ) + + header, body_stream = _headerops.get_header(instream) + header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) + old_column_names = _headerops.extract_column_names(header) + + idx_phase1 = len(old_column_names) + idx_phase2 = len(old_column_names) + 1 + if clean_output: + new_column_names = [ + col for col in old_column_names if col in _pairsam_format.COLUMNS + ] + new_column_idxs = [ + i + for i, col in enumerate(old_column_names) + if col in _pairsam_format.COLUMNS + ] + new_column_idxs += [idx_phase1, idx_phase2] + else: + new_column_names = list(old_column_names) + + new_column_names.append("phase1") + new_column_names.append("phase2") + + if report_scores: + if tag_mode=="XB": + new_column_names.append("S1_1") + new_column_names.append("S1_2") + new_column_names.append("S2_1") + new_column_names.append("S2_2") + new_column_names.append("S3_1") + new_column_names.append("S3_2") + if clean_output: + new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] + elif tag_mode=="XA": + new_column_names.append("M1_1") + new_column_names.append("M1_2") + new_column_names.append("M2_1") + new_column_names.append("M2_2") + new_column_names.append("M3_1") + new_column_names.append("M3_2") + if clean_output: + new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] + header = _headerops._update_header_entry( + header, "columns", " ".join(new_column_names) + ) + + if tag_mode == "XB": + if ( + ("XB1" not in old_column_names) + or ("XB2" not in old_column_names) + or ("AS1" not in old_column_names) + or ("AS2" not in old_column_names) + or ("XS1" not in old_column_names) + or ("XS2" not in old_column_names) + ): + raise ValueError( + "The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0" + ) + + COL_XB1 = old_column_names.index("XB1") + COL_XB2 = old_column_names.index("XB2") + COL_AS1 = old_column_names.index("AS1") + COL_AS2 = old_column_names.index("AS2") + COL_XS1 = old_column_names.index("XS1") + COL_XS2 = old_column_names.index("XS2") + + elif tag_mode == "XA": + if ( + ("XA1" not in old_column_names) + or ("XA2" not in old_column_names) + or ("NM1" not in old_column_names) + or ("NM2" not in old_column_names) + or ("AS1" not in old_column_names) + or ("AS2" not in old_column_names) + or ("XS1" not in old_column_names) + or ("XS2" not in old_column_names) + ): + raise ValueError( + "The input pairs file must be parsed with the flag --add-columns XA,NM,AS,XS --min-mapq 0" + ) + + COL_XA1 = old_column_names.index("XA1") + COL_XA2 = old_column_names.index("XA2") + COL_NM1 = old_column_names.index("NM1") + COL_NM2 = old_column_names.index("NM2") + COL_AS1 = old_column_names.index("AS1") + COL_AS2 = old_column_names.index("AS2") + COL_XS1 = old_column_names.index("XS1") + COL_XS2 = old_column_names.index("XS2") + + outstream.writelines((l + "\n" for l in header)) + + for line in body_stream: + cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) + cols.append("!") + cols.append("!") + if report_scores: + for _ in range(6): + cols.append("!") + pair_type = cols[_pairsam_format.COL_PTYPE] + + if cols[_pairsam_format.COL_C1] != _pairsam_format.UNMAPPED_CHROM: + if tag_mode == "XB": + phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XB( + cols[_pairsam_format.COL_C1], + cols[COL_XB1], + int(cols[COL_AS1]), + int(cols[COL_XS1]), + phase_suffixes, + ) + elif tag_mode == "XA": + phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XA( + cols[_pairsam_format.COL_C1], + cols[COL_XA1], + int(cols[COL_AS1]), + int(cols[COL_XS1]), + int(cols[COL_NM1]), + phase_suffixes, + ) + + if not report_scores: + cols[idx_phase1] = phase1 + else: + cols[idx_phase1], cols[idx_phase1+2], cols[idx_phase1+4], cols[idx_phase1+6] \ + = phase1, str(S1_1), str(S2_1), str(S3_1) + cols[_pairsam_format.COL_C1] = chrom_base1 + + if chrom_base1 == "!": + cols[_pairsam_format.COL_C1] = _pairsam_format.UNMAPPED_CHROM + cols[_pairsam_format.COL_P1] = str(_pairsam_format.UNMAPPED_POS) + cols[_pairsam_format.COL_S1] = _pairsam_format.UNMAPPED_STRAND + pair_type = "M" + pair_type[1] + + if cols[_pairsam_format.COL_C2] != _pairsam_format.UNMAPPED_CHROM: + + if tag_mode == "XB": + phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XB( + cols[_pairsam_format.COL_C2], + cols[COL_XB2], + int(cols[COL_AS2]), + int(cols[COL_XS2]), + phase_suffixes, + ) + elif tag_mode == "XA": + phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XA( + cols[_pairsam_format.COL_C2], + cols[COL_XA2], + int(cols[COL_AS2]), + int(cols[COL_XS2]), + int(cols[COL_NM2]), + phase_suffixes, + ) + + if not report_scores: + cols[idx_phase1] = phase2 + else: + cols[idx_phase2], cols[idx_phase2+2], cols[idx_phase2+4], cols[idx_phase2+6] \ + = phase2, str(S1_2), str(S2_2), str(S3_2) + cols[_pairsam_format.COL_C2] = chrom_base2 + + if chrom_base2 == "!": + cols[_pairsam_format.COL_C2] = _pairsam_format.UNMAPPED_CHROM + cols[_pairsam_format.COL_P2] = str(_pairsam_format.UNMAPPED_POS) + cols[_pairsam_format.COL_S2] = _pairsam_format.UNMAPPED_STRAND + pair_type = pair_type[0] + "M" + + cols[_pairsam_format.COL_PTYPE] = pair_type + + if clean_output: + cols = [cols[i] for i in new_column_idxs] + + outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) + outstream.write("\n") + + if instream != sys.stdin: + instream.close() + + if outstream != sys.stdout: + outstream.close() + + +def get_chrom_phase(chrom, phase_suffixes): + if chrom.endswith(phase_suffixes[0]): + return "0", chrom[: -len(phase_suffixes[0])] + elif chrom.endswith(phase_suffixes[1]): + return "1", chrom[: -len(phase_suffixes[1])] + else: + return "!", chrom + + +def phase_side_XB(chrom, XB, AS, XS, phase_suffixes): + + phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) + + XBs = [i for i in XB.split(';') if len(i) > 0] + S1, S2, S3 = AS, XS, -1 # -1 if the second hit was not reported + + if AS > XS: # Primary hit has higher score than the secondary + return phase, chrom_base, S1, S2, S3 + + elif len(XBs) >= 1: + if len(XBs) >= 2: + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS, alt_mapq = XBs[1].split(',') + S3 = int(alt2_AS) + if int(alt2_AS) == XS == AS: + return '!', '!', S1, S2, S3 + + alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS, alt_mapq = XBs[0].split(',') + alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) + + alt_is_homologue = ( + (chrom_base == alt_chrom_base) + and + ( + ((phase == '0') and (alt_phase == '1')) + or + ((phase == '1') and (alt_phase == '0')) + ) + ) + + if alt_is_homologue: + return '.', chrom_base, S1, S2, S3 + + return '!', '!', S1, S2, S3 + + +def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): + + phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) + + XAs = [i for i in XA.split(";") if len(i.strip()) > 0] + if len(XAs) >= 1: + alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") + M1, M2, M3 = NM, int(alt_NM), -1 + else: + M1, M2, M3 = NM, -1, -1 # -1 if the second hit was not reported + + if (AS > XS): # Primary hit has higher score than the secondary + return phase, chrom_base, M1, M2, M3 + + elif len(XAs) >= 1: + + if len(XAs) >= 2: + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM = XAs[1].split(",") + M3 = int(alt2_NM) + if int(alt2_NM) == int(alt_NM) == NM: + return "!", "!", M1, M2, M3 + + alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") + + alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) + + alt_is_homologue = (chrom_base == alt_chrom_base) and ( + ((phase == "0") and (alt_phase == "1")) + or ((phase == "1") and (alt_phase == "0")) + ) + + if alt_is_homologue: + return ".", chrom_base, M1, M2, M3 + + return "!", "!", M1, M2, M3 From 1bd71e6fdea8eddcefb8ab154b010a8ce942515f Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 06:43:37 -0400 Subject: [PATCH 21/52] Removed python 3.10 testing becuase of glibc problem in conda --- .github/workflows/python-package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index f8caa6c5..8b1f19f3 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -15,7 +15,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.7", "3.8", "3.9", "3.10"] + python-version: ["3.7", "3.8", "3.9"] steps: - uses: actions/checkout@v2 @@ -42,7 +42,7 @@ jobs: export PATH="$HOME/miniconda/bin:$PATH" hash -r conda config --set always_yes yes --set changeps1 no - conda config --add channels conda-forge + conda config --add channels conda-forge conda config --add channels defaults conda config --add channels bioconda conda config --get From edfa4f32aa59fc26b34a190ae93603e6980fb4ea Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Thu, 14 Apr 2022 08:01:40 -0400 Subject: [PATCH 22/52] phase unmapped chrom fix --- pairtools/cli/phase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pairtools/cli/phase.py b/pairtools/cli/phase.py index 045c7203..5ceec1b2 100644 --- a/pairtools/cli/phase.py +++ b/pairtools/cli/phase.py @@ -197,7 +197,7 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ cols.append("!") if report_scores: for _ in range(6): - cols.append("!") + cols.append("-1") pair_type = cols[pairsam_format.COL_PTYPE] if cols[pairsam_format.COL_C1] != pairsam_format.UNMAPPED_CHROM: From cfd2c0698ceb14964c8ccf23ae13a2660a3b3084 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Sat, 16 Apr 2022 03:00:43 -0400 Subject: [PATCH 23/52] add_cols fix for lib.parse --- pairtools/cli/parse.py | 7 ++++++- pairtools/lib/parse.py | 13 +++++++++---- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/pairtools/cli/parse.py b/pairtools/cli/parse.py index 18052b3c..d0b37f08 100644 --- a/pairtools/cli/parse.py +++ b/pairtools/cli/parse.py @@ -267,7 +267,12 @@ def parse_py( ### Parse input and write to the outputs streaming_classify( - input_sam, outstream, chromosomes, out_alignments_stream, out_stat, **kwargs + input_sam, + outstream, + chromosomes, + out_alignments_stream, + out_stat, + **kwargs ) # save statistics to a file if it was requested: diff --git a/pairtools/lib/parse.py b/pairtools/lib/parse.py index a035e3cc..69c231c8 100644 --- a/pairtools/lib/parse.py +++ b/pairtools/lib/parse.py @@ -74,7 +74,12 @@ def streaming_classify( range(len(chromosomes) + 1), ) ) - add_columns = kwargs.get("add_columns", "").split(",") + add_columns = kwargs.get("add_columns", "") + if isinstance(add_columns, str): + add_columns = add_columns.split(",") + elif not isinstance(add_columns, list): + raise ValueError(f"Unknown type of add_columns: {type(add_columns)}") + sam_tags = [col for col in add_columns if len(col) == 2 and col.isupper()] store_seq = "seq" in add_columns @@ -162,7 +167,7 @@ def streaming_classify( drop_seq=kwargs["drop_seq"], drop_sam=kwargs["drop_sam"], add_pair_index=kwargs["add_pair_index"], - add_columns=kwargs["add_columns"], + add_columns=add_columns, ) # add a pair to PairCounter for stats output: @@ -341,7 +346,7 @@ def flip_alignment(hic_algn): """ hic_algn = dict(hic_algn) # overwrite the variable with the copy of dictionary hic_algn["pos5"], hic_algn["pos3"] = hic_algn["pos3"], hic_algn["pos5"] - hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" + hic_algn["strand"] = "+" if (hic_algn["strand"] == "-") else "-" return hic_algn @@ -352,7 +357,7 @@ def flip_orientation(hic_algn): :return: """ hic_algn = dict(hic_algn) # overwrite the variable with the copy of dictionary - hic_algn["strand"] = "+" if hic_algn["strand"] == "-" else "-" + hic_algn["strand"] = "+" if (hic_algn["strand"] == "-") else "-" return hic_algn From a1059e0ddfa538a8f1951c130cd11f07ae71b9d0 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 19 Apr 2022 06:59:19 -0400 Subject: [PATCH 24/52] additional columns fix --- pairtools/cli/parse.py | 5 +++-- pairtools/cli/parse2.py | 5 +++-- pairtools/lib/parse.py | 6 ++++-- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/pairtools/cli/parse.py b/pairtools/cli/parse.py index d0b37f08..be20bb84 100644 --- a/pairtools/cli/parse.py +++ b/pairtools/cli/parse.py @@ -160,8 +160,9 @@ show_default=True, ) @click.option( - "--no-flip", + "--flip/--no-flip", is_flag=True, + default=True, help="If specified, do not flip pairs in genomic order and instead preserve " "the order in which they were sequenced.", ) @@ -258,7 +259,7 @@ def parse_py( assembly=kwargs.get("assembly", ""), chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], columns=columns, - shape="whole matrix" if kwargs["no_flip"] else "upper triangle", + shape="whole matrix" if not kwargs["flip"] else "upper triangle", ) header = headerops.insert_samheader_pysam(header, samheader) diff --git a/pairtools/cli/parse2.py b/pairtools/cli/parse2.py index 8b866f9b..3dd38f4d 100644 --- a/pairtools/cli/parse2.py +++ b/pairtools/cli/parse2.py @@ -119,8 +119,9 @@ "--single-end", is_flag=True, help="If specified, the input is single-end." ) @click.option( - "--no-flip", + "--flip/--no-flip", is_flag=True, + default=True, help="If specified, do not flip pairs in genomic order and instead preserve " "the order in which they were sequenced.", ) @@ -280,7 +281,7 @@ def parse2_py( assembly=kwargs.get("assembly", ""), chromsizes=[(chrom, sam_chromsizes[chrom]) for chrom in chromosomes], columns=columns, - shape="whole matrix" if kwargs["no_flip"] else "upper triangle", + shape="whole matrix" if not kwargs["flip"] else "upper triangle", ) header = headerops.insert_samheader_pysam(header, samheader) diff --git a/pairtools/lib/parse.py b/pairtools/lib/parse.py index 69c231c8..b38f8bfc 100644 --- a/pairtools/lib/parse.py +++ b/pairtools/lib/parse.py @@ -75,8 +75,10 @@ def streaming_classify( ) ) add_columns = kwargs.get("add_columns", "") - if isinstance(add_columns, str): + if isinstance(add_columns, str) and len(add_columns)>0: add_columns = add_columns.split(",") + elif len(add_columns)==0: + add_columns = [] elif not isinstance(add_columns, list): raise ValueError(f"Unknown type of add_columns: {type(add_columns)}") @@ -149,7 +151,7 @@ def streaming_classify( algn1["pos"] = algn1["pos3"] algn2["pos"] = algn2["pos3"] - if not kwargs["no_flip"]: + if kwargs["flip"]: flip_pair = not check_pair_order(algn1, algn2, chrom_enum) if flip_pair: algn1, algn2 = algn2, algn1 From 072bacc8216039104b879776346c57064b36f132 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 19 Apr 2022 08:50:20 -0400 Subject: [PATCH 25/52] logger added --- pairtools/_logging.py | 16 ++++++++ pairtools/cli/__init__.py | 86 ++++++++++++++++++++++++++++++++++++++- pairtools/lib/dedup.py | 7 ++-- 3 files changed, 105 insertions(+), 4 deletions(-) create mode 100644 pairtools/_logging.py diff --git a/pairtools/_logging.py b/pairtools/_logging.py new file mode 100644 index 00000000..bfaf39f8 --- /dev/null +++ b/pairtools/_logging.py @@ -0,0 +1,16 @@ +import logging + +_loggers = {} + + +def get_logger(name="pairtools"): + # Based on ipython traitlets + global _loggers + + if name not in _loggers: + _loggers[name] = logging.getLogger(name) + # Add a NullHandler to silence warnings about not being + # initialized, per best practice for libraries. + _loggers[name].addHandler(logging.NullHandler()) + + return _loggers[name] diff --git a/pairtools/cli/__init__.py b/pairtools/cli/__init__.py index 25a3f4f7..a1d85d81 100644 --- a/pairtools/cli/__init__.py +++ b/pairtools/cli/__init__.py @@ -4,6 +4,9 @@ import functools import sys from .. import __version__ +import logging +from .._logging import get_logger + CONTEXT_SETTINGS = { "help_option_names": ["-h", "--help"], @@ -22,7 +25,15 @@ type=str, default="", ) -def cli(post_mortem, output_profile): +@click.option("-v", "--verbose", help="Verbose logging.", count=True) +@click.option( + "-d", + "--debug", + help="On error, drop into the post-mortem debugger shell.", + is_flag=True, + default=False, +) +def cli(post_mortem, output_profile, verbose, debug): """Flexible tools for Hi-C data processing. All pairtools have a few common options, which should be typed _before_ @@ -57,6 +68,79 @@ def _atexit_profile_hook(): atexit.register(_atexit_profile_hook) + # Initialize logging to stderr + logging.basicConfig(stream=sys.stderr) + logging.captureWarnings(True) + root_logger = get_logger() + + # Set verbosity level + if verbose > 0: + root_logger.setLevel(logging.DEBUG) + if verbose > 1: # pragma: no cover + try: + import psutil + import atexit + + @atexit.register + def process_dump_at_exit(): + process_attrs = [ + "cmdline", + # 'connections', + "cpu_affinity", + "cpu_num", + "cpu_percent", + "cpu_times", + "create_time", + "cwd", + # 'environ', + "exe", + # 'gids', + "io_counters", + "ionice", + "memory_full_info", + # 'memory_info', + # 'memory_maps', + "memory_percent", + "name", + "nice", + "num_ctx_switches", + "num_fds", + "num_threads", + "open_files", + "pid", + "ppid", + "status", + "terminal", + "threads", + # 'uids', + "username", + ] + p = psutil.Process() + info_ = p.as_dict(process_attrs, ad_value="") + for key in process_attrs: + root_logger.debug("PSINFO:'{}': {}".format(key, info_[key])) + + except ImportError: + root_logger.warning("Install psutil to see process information.") + + else: + root_logger.setLevel(logging.INFO) + + # Set hook for postmortem debugging + if debug: # pragma: no cover + import traceback + + try: + import ipdb as pdb + except ImportError: + import pdb + + def _excepthook(exc_type, value, tb): + traceback.print_exception(exc_type, value, tb) + print() + pdb.pm() + + sys.excepthook = _excepthook def common_io_options(func): @click.option( diff --git a/pairtools/lib/dedup.py b/pairtools/lib/dedup.py index a30a2444..452ec584 100644 --- a/pairtools/lib/dedup.py +++ b/pairtools/lib/dedup.py @@ -10,7 +10,8 @@ from .markasdup import mark_split_pair_as_dup from .stats import PairCounter - +from .._logging import get_logger +logger = get_logger() import time # Setting for cython deduplication: @@ -97,8 +98,8 @@ def streaming_dedup( t1 = time.time() t = t1 - t0 - print(f"total time: {t}") - print(f"time per mln pairs: {t/N*1e6}") + logger.debug(f"total time: {t}") + logger.debug(f"time per mln pairs: {t/N*1e6}") def _dedup_stream( From 7f7fbaac6186dfae4ddd66cb65c9d46adc9ddc1e Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 19 Apr 2022 09:32:25 -0400 Subject: [PATCH 26/52] junction index update and parsing docs fix --- doc/_static/report-orientation.svg | 240 +++++------ doc/_static/report-positions.svg | 512 +++++++++++++---------- doc/_static/rescue_modes.svg | 194 ++++++--- doc/_static/rescue_modes_readthrough.svg | 414 ++++++++++-------- doc/parsing.rst | 4 +- pairtools/cli/parse.py | 3 +- pairtools/cli/parse2.py | 3 +- pairtools/lib/pairsam_format.py | 3 +- pairtools/lib/parse.py | 73 ++-- tests/data/mock.parse-all.sam | 106 ++--- tests/data/mock.parse2.sam | 106 ++--- tests/test_parse.py | 2 +- tests/test_parse2.py | 4 +- 13 files changed, 932 insertions(+), 732 deletions(-) diff --git a/doc/_static/report-orientation.svg b/doc/_static/report-orientation.svg index c844701c..176c8b57 100755 --- a/doc/_static/report-orientation.svg +++ b/doc/_static/report-orientation.svg @@ -1,128 +1,134 @@ - - Slice 1 + + report-orientation - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - read - - - { - - - walk - - - { - - - pair - - - { - - - deafault for both - parse --walks-policy all - and parse2 - - - junction - - - { - - - - - - + + + + + + + + + + - - - - - - + + read + + + { + + + walk + + + { + + + pair + + + { + + + default for both + + + parse --walks-policy all + + + and parse2 + + + junction + + + { + + + + + + + - - - + + + + + + + + + + - - - - - - + + + + + + + + + + --report-orientation + - - - - --report-orientation - \ No newline at end of file diff --git a/doc/_static/report-positions.svg b/doc/_static/report-positions.svg index 71aea174..a3f107f4 100755 --- a/doc/_static/report-positions.svg +++ b/doc/_static/report-positions.svg @@ -1,271 +1,337 @@ - Slice 1 + report-positions - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + - - * - - - * - - - * - - - + + + + - - - - - * - - - * - - - * - - - read - - - { - - - - - - - - - - - - - - - - - - * - - - * - - - * - - - - - - + + + + + + + + + + + + + + + + + + - - * - - - * - - - * - - - walk - - - { - - - - - - + + + - + - + - + - - * - - - * - - - * - - + + + * + + + + + * + + + + + * + + + - + - - * - - - * + + + * + + + + + * + + + + + * + + + + + + read - - * + + + + { - - outer - - - { - - - deafault for - parse --walks-policy all - - - - - - + + + - + - + - + - - * - - - * - - - * - - + + + * + + + + + * + + + + + * + + + - + - - * + + + * + + + + + * + + + + + * + + + + + + walk - - * + + + + { - - * + + + + + + + + + + + + + + + + + + + + * + + + + + * + + + + + * + + + + + + + + + + + * + + + + + * + + + + + * + + + + + outer + + + { + + + + + default for + + + parse --walks-policy all - - junction - - - { - - - deafult for - parse2 - - - - - - - + + + + + + + + + + + + + + + + + + * + + + + + * + + + + + * + + + + + + + + + + + * + + + + + * + + + + + * + + + + + junction + + + { + + + + + default for + + + parse2 + + - - - - - - + + + + + + - - - + + + + + + + + + + - - - - - - + + + + + + + + + + --report-position + - - - - --report-position - \ No newline at end of file diff --git a/doc/_static/rescue_modes.svg b/doc/_static/rescue_modes.svg index 31b8842b..491a5694 100644 --- a/doc/_static/rescue_modes.svg +++ b/doc/_static/rescue_modes.svg @@ -1,8 +1,8 @@ - - Slice 1 + + Group 2 - + @@ -10,39 +10,47 @@ - + - + - - 3r - + + + 3 + + - - UU - + + + UU + + - + - - 2u - + + + 2 + + - - UU - + + + UU + + - + - + - + @@ -54,16 +62,16 @@ - + - - - + + + @@ -99,48 +107,100 @@ - - UU - - - all - - - mask - - - 5any, 5unique - - - --walks-policy - - - pair_index: - - - 1l - - - UU - - - 3any, 3unique - - - UU - - - WW - - - ! - - - ! - - - { - + + + UU + + + + + all + + + + + mask + + + + + 5any, 5unique + + + + + --walks-policy + + + + + walk_pair_index + + + + + 1 + + + + + + R2 + + + + + + + R1/2 + + + + + + walk_pair_type + + + + + R1 + + + + + UU + + + + + 3any, 3unique + + + + + UU + + + + + WW + + + + + ! + + + + + ! + + + + + { + + \ No newline at end of file diff --git a/doc/_static/rescue_modes_readthrough.svg b/doc/_static/rescue_modes_readthrough.svg index 2e6da006..838d0620 100644 --- a/doc/_static/rescue_modes_readthrough.svg +++ b/doc/_static/rescue_modes_readthrough.svg @@ -1,188 +1,246 @@ - - Slice 1 + + Group 2 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + + + - - - - - - + + + + + + + + - - - + + + + + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + all + + + + + + + mask + + + + + + + 5any, 5unique + + + + + + + --walks-policy + + + + + + + UU + + + + + + + UU + + + + + + + UU + + + + + + + UU + + + + + + + 3any, 3unique + + + + + + + UU + + + + + + + WW + + + + + + + ! + + + + + + + ! + + + + + + + { + + + + + + + 3 + + + + + + + 2 + + + + + + walk_pair_index + + + + + 1 + + + + + + R2 + + + + + + + R1&2 + + + + + + walk_pair_type + + + + + R1 + - - - - - - - - all - - - - - mask - - - - - 5any, 5unique - - - - - --walks-policy - - - - - pair_index - - - - - 1l - - - - - 2b - - - - - 3r - - - - - UU - - - - - UU - - - - - UU - - - - - UU - - - - - 3any, 3unique - - - - - UU - - - - - WW - - - - - ! - - - - - ! - - - - - { - \ No newline at end of file diff --git a/doc/parsing.rst b/doc/parsing.rst index a076fd46..a4c1cb24 100644 --- a/doc/parsing.rst +++ b/doc/parsing.rst @@ -250,7 +250,7 @@ all pairs in the walk to be reported as if they appeared in the sequencing data By default, ``parse2`` reports ligation junctions instead of outer ends of the alignmentns. It may report also the position or orientation of the walk or of individual read. -The complete guide through the reporting options of ``parse2``: +The complete guide through the reporting options of ``parse2``, orientation reporting: .. figure:: _static/report-orientation.svg :width: 60 % @@ -258,6 +258,8 @@ The complete guide through the reporting options of ``parse2``: :align: center +position reporting: + .. figure:: _static/report-positions.svg :width: 60 % :alt: parse2 --report-position diff --git a/pairtools/cli/parse.py b/pairtools/cli/parse.py index be20bb84..529d6dc2 100644 --- a/pairtools/cli/parse.py +++ b/pairtools/cli/parse.py @@ -240,7 +240,8 @@ def parse_py( columns.pop(columns.index("sam2")) if not kwargs.get("add_pair_index", False): - columns.pop(columns.index("pair_index")) + columns.pop(columns.index("walk_pair_index")) + columns.pop(columns.index("walk_pair_type")) ### Parse header samheader = input_sam.header diff --git a/pairtools/cli/parse2.py b/pairtools/cli/parse2.py index 3dd38f4d..75f7bff4 100644 --- a/pairtools/cli/parse2.py +++ b/pairtools/cli/parse2.py @@ -262,7 +262,8 @@ def parse2_py( columns.pop(columns.index("sam2")) if not kwargs.get("add_pair_index", False): - columns.pop(columns.index("pair_index")) + columns.pop(columns.index("walk_pair_index")) + columns.pop(columns.index("walk_pair_type")) ### Parse header samheader = input_sam.header diff --git a/pairtools/lib/pairsam_format.py b/pairtools/lib/pairsam_format.py index 8be5e298..6f4479a4 100644 --- a/pairtools/lib/pairsam_format.py +++ b/pairtools/lib/pairsam_format.py @@ -28,7 +28,8 @@ "pair_type", "sam1", "sam2", - "pair_index", + "walk_pair_index", + "walk_pair_type" ] # Required columns for formats: diff --git a/pairtools/lib/parse.py b/pairtools/lib/parse.py index b38f8bfc..c45161e4 100644 --- a/pairtools/lib/parse.py +++ b/pairtools/lib/parse.py @@ -411,7 +411,7 @@ def parse_read( algns2 = [empty_alignment()] algns1[0]["type"] = "X" algns2[0]["type"] = "X" - pair_index = "1u" + pair_index = (1, "R1/2") return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments @@ -428,7 +428,7 @@ def parse_read( # By default, assume each molecule is a single pair with single unconfirmed pair: hic_algn1 = algns1[0] hic_algn2 = algns2[0] - pair_index = "1u" + pair_index = (1, "R1/2") # Define the type of alignment on each side: is_chimeric_1 = len(algns1) > 1 @@ -458,7 +458,7 @@ def parse_read( # Walk was rescued as a simple walk: if rescued_linear_side is not None: - pair_index = f'1{"l" if rescued_linear_side==1 else "r"}' + pair_index = (1, "R1" if rescued_linear_side==1 else "R2") # Walk is unrescuable: else: if walks_policy == "mask": @@ -539,7 +539,7 @@ def parse2_read( algn1, algn2: dict Two alignments selected for reporting as a Hi-C pair. pair_index - pair index of a pair in the molecule. + pair index of a pair in the molecule, a tuple: (1, "R1/2") algns1, algns2: lists All alignments, sorted according to their order in on a read. """ @@ -578,7 +578,8 @@ def parse2_read( algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) - return iter([(algns1[0], algn2, "1u")]), algns1, algns2 + pair_index = (1, "R1/2") + return iter([(algns1[0], algn2, pair_index)]), algns1, algns2 # Paired-end mode: else: @@ -588,7 +589,8 @@ def parse2_read( algns2 = [empty_alignment()] algns1[0]["type"] = "X" algns2[0]["type"] = "X" - return iter([(algns1[0], algns2[0], "1u")]), algns1, algns2 + pair_index = (1, "R1/2") + return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments algns1 = [ @@ -629,7 +631,8 @@ def parse2_read( algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) - return iter([(algns1[0], algn2, "1u")]), algns1, algns2 + pair_index = (1, "R1/2") + return iter([(algns1[0], algn2, pair_index)]), algns1, algns2 #################### @@ -912,11 +915,12 @@ def parse_complex_walk( if ( n_algns1 >= 2 ): # single alignment on right read and multiple alignments on left + pair_index = (len(algns1)-1, "R1") output_pairs.append( format_pair( algns1[-2], algns1[-1], - pair_index=f"{len(algns1)-1}l", + pair_index=pair_index, algn2_pos3=algns2[-1]["pos5"], report_position=report_position, report_orientation=report_orientation, @@ -927,11 +931,12 @@ def parse_complex_walk( if ( n_algns2 >= 2 ): # single alignment on left read and multiple alignments on right + pair_index = (len(algns1), "R2") output_pairs.append( format_pair( algns2[-1], algns2[-2], - pair_index=f"{len(algns1)}r", + pair_index=pair_index, algn1_pos3=algns1[-1]["pos5"], report_position=report_position, report_orientation=report_orientation, @@ -943,11 +948,12 @@ def parse_complex_walk( # it's a non-ligated DNA fragment that we don't report. else: # end alignments do not overlap, report regular pair: + pair_index = (len(algns1), "R1/2") output_pairs.append( format_pair( algns1[-1], algns2[-1], - pair_index=f"{len(algns1)}u", + pair_index=pair_index, report_position=report_position, report_orientation=report_orientation, ) @@ -961,11 +967,12 @@ def parse_complex_walk( # III. Report all remaining alignments. # Report all unique alignments on left read (sequential): for i in range(0, n_algns1 - last_reported_alignment_left): + pair_index = (i + 1, "R1") output_pairs.append( format_pair( algns1[i], algns1[i + 1], - pair_index=f"{i + 1}l", + pair_index=pair_index, report_position=report_position, report_orientation=report_orientation, ) @@ -975,11 +982,12 @@ def parse_complex_walk( for i_overlapping in range(current_right_pair - 1): idx_left = n_algns1 - current_right_pair + i_overlapping idx_right = n_algns2 - 1 - i_overlapping + pair_index = (idx_left + 1, "R1&2") output_pairs.append( format_pair( algns1[idx_left], algns1[idx_left + 1], - pair_index=f"{idx_left + 1}b", + pair_index=pair_index, algn2_pos3=algns2[idx_right - 1]["pos5"], report_position=report_position, report_orientation=report_orientation, @@ -993,28 +1001,24 @@ def parse_complex_walk( for i in reporting_order: # Determine the pair index depending on what is the overlap: shift = -1 if current_right_pair > 1 else 0 - pair_index = ( + pair_index = (( n_algns1 + min(current_right_pair, n_algns2 - last_reported_alignment_right) - i + shift - ) + ), "R2") output_pairs.append( format_pair( algns2[i + 1], algns2[i], - pair_index=f"{pair_index}r", + pair_index=pair_index, report_position=report_position, report_orientation=report_orientation, ) ) # Sort the pairs according by the pair index: - walk_length = max([int(x[-1][:-1]) for x in output_pairs]) - # if report_position=="walk": - output_pairs.sort(key=lambda x: int(x[-1][:-1])) - # else: # oder by position to the 5'-end of the read (left or right independently) - # output_pairs.sort(key=lambda x: int(x[-1][:-1]) if x[-1][-1]!='r' else walk_length-int(x[-1][:-1])) + output_pairs.sort(key=lambda x: int(x[-1][0])) return iter(output_pairs) @@ -1184,25 +1188,25 @@ def format_pair( # Change orientation and positioning of pair for reporting: # AVAILABLE_REPORT_POSITION = ["outer", "pair", "read", "walk"] # AVAILABLE_REPORT_ORIENTATION = ["pair", "pair", "read", "walk"] - pair_type = pair_index[-1] + pair_type = pair_index[1] if report_orientation == "read": pass elif report_orientation == "walk": - if pair_type == "r": + if pair_type == "R2": hic_algn1 = flip_orientation(hic_algn1) hic_algn2 = flip_orientation(hic_algn2) - elif pair_type == "u": + elif pair_type == "R1/2": hic_algn2 = flip_orientation(hic_algn2) elif report_orientation == "pair": - if pair_type == "l": + if pair_type == "R1" or pair_type == "R1&R2": hic_algn2 = flip_orientation(hic_algn2) - elif pair_type == "r": + elif pair_type == "R2": hic_algn1 = flip_orientation(hic_algn1) elif report_orientation == "junction": - if pair_type == "l": + if pair_type == "R1" or pair_type == "R1&R2": hic_algn1 = flip_orientation(hic_algn1) - elif pair_type == "r": + elif pair_type == "R2": hic_algn2 = flip_orientation(hic_algn2) else: hic_algn1 = flip_orientation(hic_algn1) @@ -1211,20 +1215,20 @@ def format_pair( if report_position == "read": pass elif report_position == "walk": - if pair_type == "r": + if pair_type == "R2": hic_algn1 = flip_position(hic_algn1) hic_algn2 = flip_position(hic_algn2) - elif pair_type == "u": + elif pair_type == "R1/2": hic_algn2 = flip_position(hic_algn2) elif report_position == "outer": - if pair_type == "l": + if pair_type == "R1" or pair_type == "R1&R2": hic_algn2 = flip_position(hic_algn2) - elif pair_type == "r": + elif pair_type == "R2": hic_algn1 = flip_position(hic_algn1) elif report_position == "junction": - if pair_type == "l": + if pair_type == "R1" or pair_type == "R1&R2": hic_algn1 = flip_position(hic_algn1) - elif pair_type == "r": + elif pair_type == "R2": hic_algn2 = flip_position(hic_algn2) else: hic_algn1 = flip_position(hic_algn1) @@ -1349,7 +1353,8 @@ def write_pairsam( ) if add_pair_index: - cols.append(pair_index) + cols.append(str(pair_index[0])) + cols.append(pair_index[1]) for col in add_columns: # use get b/c empty alignments would not have sam tags (NM, AS, etc) diff --git a/tests/data/mock.parse-all.sam b/tests/data/mock.parse-all.sam index c5766397..86abdd99 100644 --- a/tests/data/mock.parse-all.sam +++ b/tests/data/mock.parse-all.sam @@ -1,56 +1,56 @@ @SQ SN:chr1 LN:10000 @SQ SN:chr2 LN:10000 @PG ID:mock PN:mock VN:0.0.0 CL:mock -readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u -readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u -readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u -readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u -readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u -readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u -readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u -readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u -readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u -readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u -readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u -readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u -readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u -readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u -readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u -readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u -readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|chr1,200,chr1,5324,+,-,UU,2u -readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,200,chr1,300,+,+,UU,2u -readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,200,chr1,300,+,+,UU,2u -readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1l|chr1,200,chr1,300,+,+,UU,2u -readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1l -readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r -readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r -readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r -readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1l|chr1,300,chr1,2000,+,+,UU,2u|chr1,200,chr1,2024,+,-,UU,3r -readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u -readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u -readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,NU,2u -readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u -readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u -readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1l|!,0,chr1,5324,-,-,MU,2u -readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1u +readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 +readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 +readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 +readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 +readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 +readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 +readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 +readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 +readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 +readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 +readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 +readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 +readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 +readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 +readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1/2 diff --git a/tests/data/mock.parse2.sam b/tests/data/mock.parse2.sam index dac50e20..786c8771 100644 --- a/tests/data/mock.parse2.sam +++ b/tests/data/mock.parse2.sam @@ -1,56 +1,56 @@ @SQ SN:chr1 LN:10000 @SQ SN:chr2 LN:10000 @PG ID:mock PN:mock VN:0.0.0 CL:mock -readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u -readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1u -readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1u -readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u -readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1u -readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1u -readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u -readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1u -readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1u -readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u -readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1u -readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1u -readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u -readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1u -readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u -readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1u -readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u -readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1u -readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u -readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u -readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|chr1,249,chr1,5300,+,-,UU,2u -readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u -readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u -readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,249,chr1,324,+,+,UU,2u -readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1l -readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r -readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r -readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r -readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1l|chr1,324,chr1,2024,+,+,UU,2u|chr1,224,chr1,2000,+,-,UU,3r -readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u -readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u -readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,NU,2u -readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1l|!,0,chr1,5300,-,-,MU,2u -readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1l|!,0,chr1,5300,-,-,MU,2u -readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1l|!,0,chr1,5300,-,-,MU,2u -readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1u +readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 +readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 +readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 +readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 +readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 +readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 +readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 +readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 +readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 +readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 +readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 +readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 +readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 +readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 +readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 +readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 +readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 +readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 +readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1/2 diff --git a/tests/test_parse.py b/tests/test_parse.py index 02d5e5be..d9fed03b 100644 --- a/tests/test_parse.py +++ b/tests/test_parse.py @@ -100,7 +100,7 @@ def test_mock_pysam_parse_all(): id_counter = 0 prev_id = l.split("\t")[0] - assigned_pair = l.split("\t")[1:8] + [l.split("\t")[-1]] + assigned_pair = l.split("\t")[1:8] + l.split("\t")[-2:] simulated_pair = ( l.split("CT:Z:SIMULATED:", 1)[1] .split("\031", 1)[0] diff --git a/tests/test_parse2.py b/tests/test_parse2.py index f00387c0..1712e705 100644 --- a/tests/test_parse2.py +++ b/tests/test_parse2.py @@ -53,7 +53,7 @@ def test_mock_pysam_parse2_read(): id_counter = 0 prev_id = l.split("\t")[0] - assigned_pair = l.split("\t")[1:8] + [l.split("\t")[-1]] + assigned_pair = l.split("\t")[1:8] + l.split("\t")[-2:] simulated_pair = ( l.split("SIMULATED:", 1)[1] .split("\031", 1)[0] @@ -111,7 +111,7 @@ def test_mock_pysam_parse2_pair(): id_counter = 0 prev_id = l.split("\t")[0] - assigned_pair = l.split("\t")[1:8] + [l.split("\t")[-1]] + assigned_pair = l.split("\t")[1:8] + l.split("\t")[-2:] simulated_pair = ( l.split("SIMULATED:", 1)[1] .split("\031", 1)[0] From 578bbd4ca0bee393572c54f550d2f383bab3ba94 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 19 Apr 2022 14:55:11 -0400 Subject: [PATCH 27/52] Example walkthrough added. --- .gitignore | 3 + doc/parsing.rst | 16 +- examples/pairtools_walkthrough.ipynb | 1602 ++++++++++++++++++++++++++ 3 files changed, 1613 insertions(+), 8 deletions(-) create mode 100644 examples/pairtools_walkthrough.ipynb diff --git a/.gitignore b/.gitignore index cd90659d..3d5d10ad 100644 --- a/.gitignore +++ b/.gitignore @@ -98,3 +98,6 @@ _*.c # VS code settings .vscode/* + +# Files generated as the examples +examples/* diff --git a/doc/parsing.rst b/doc/parsing.rst index a4c1cb24..17475af3 100644 --- a/doc/parsing.rst +++ b/doc/parsing.rst @@ -266,16 +266,16 @@ position reporting: :align: center -To restore the sequence of ligation events, there is a special field ``pair_index`` that you have as -a separate column of .pair file when setting ``--add-pair-index`` option. This field contains information on: +To restore the sequence of ligation events, there are special fields ``walk_pair_index`` and ``walk_pair_type`` that you have as +a separate column of .pair file when setting ``--add-pair-index`` option. -- the order of the pair in the recovered walk, starting from 5'-end of left read -- type of the pair: +- ``walk_pair_index`` contains information on the order of the pair in the recovered walk, starting from 5'-end of left read +- ``walk_pair_type`` describes the type of the pair relative to R1 and R2 reads of paired-end sequencing: - - "u" - unconfirmed pair, right and left alignments in the pair originate from different reads (left or right). This might be indirect ligation (mediated by other DNA fragments). - - "l" - pair originates from the left read. This is direct ligation. - - "r" - pair originated from the right read. Direct ligation. - - "b" - pair was sequenced at both left and right read. Direct ligation. + - "R1/2" - unconfirmed pair, right and left alignments in the pair originate from different reads (left or right). This might be indirect ligation (mediated by other DNA fragments). + - "R1" - pair originates from the left read. This is direct ligation. + - "R2" - pair originated from the right read. Direct ligation. + - "R1&2" - pair was sequenced at both left and right read. Direct ligation. With this information, the whole sequence of ligation events can be restored from the .pair file. diff --git a/examples/pairtools_walkthrough.ipynb b/examples/pairtools_walkthrough.ipynb new file mode 100644 index 00000000..2eefbf25 --- /dev/null +++ b/examples/pairtools_walkthrough.ipynb @@ -0,0 +1,1602 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "112fe2d5-aaed-4eb1-b3f5-2f5889a9c89f", + "metadata": {}, + "source": [ + "# Pairtools walkthrough\n", + "\n", + "Welcome to the pairtools walkthrough. \n", + "\n", + "Pairtools is a tool for extraction of pairwise contacts out of sequencing chromosomes conformation capture data, such as Hi-C, Micro-C or MC-3C.\n", + "Pairtools is used for obtaining .cool files by [distiller](https://github.com/open2c/distiller-nf/blob/master/distiller.nf), and has many more applications (see single-cell walkthrough or phasing walkthrough). \n", + "\n", + "Here, we will cover the basic steps from raw reads to .cool file with binned contacts." + ] + }, + { + "cell_type": "markdown", + "id": "bd264406-be74-4060-9798-e18040c44889", + "metadata": {}, + "source": [ + "### Download raw data\n", + "\n", + "\"Raw\" data, or .fastq files are generated by sequencing facilities or can be taken from public databases, such as SRA. We will take a sample from Rao et at al. 2017, human datasets.\n", + "To reduce computateion time, take 5 mln reads instead of full sample:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f4e310c0-2d16-4e7d-87d7-44feec8e6256", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Read 5000000 spots for SRR13849430\n", + "Written 5000000 spots for SRR13849430\n" + ] + } + ], + "source": [ + "! fastq-dump SRR13849430 --gzip --split-spot --split-3 --minSpotId 0 --maxSpotId 5000000" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "571e94fb-3dec-4042-9e21-6c39802ed8df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRR13849430_1.fastq.gz\tSRR8058285_1.fastq.gz\n", + "SRR13849430_2.fastq.gz\tSRR8058285_2.fastq.gz\n" + ] + } + ], + "source": [ + "! ls SRR13849430*.fastq.gz" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e9fb044d-1ba0-48c7-b40a-99d033518e43", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "@SRR13849430.1 1 length=150\n", + "NTCTCAGCCTTTATAAGATAGAAGAGAGTTGGGACCTTGCTCTAAATTCTGCTTTAGCAAGGGACTTTTGTACCTGCTTTCTTCCTTTATCCAGATCTAAAAATAGTTTATATGCTGACAACTCCCTGATGTTATTCTTTGTAGTATTTG\n", + "+SRR13849430.1 1 length=150\n", + "#AAFFJJJJJJJJJJJAJAJJJJFJJJAFFFFFFA7A-FJ7JJJ-AJAJJF-<-JJFFJ7FJJF7FJJFJJ test.bam" + ] + }, + { + "cell_type": "markdown", + "id": "89f9d829-3f79-49b4-b74d-8bca732b8a44", + "metadata": {}, + "source": [ + "After mapping, you have .sam/.bam alignment file, which cannot be interpreted as pairs directly. You need to extract contacts from it:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "955bcafa-e521-4627-8c8b-94e05e46e6b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRR13849430.1\t121\tchr12\t78795720\t60\t53S97M\t=\t78795720\t0\tCAAATACTACAAAGAATAACATCAGGGAGTTGTCAGCATATAAACTATTTTTAGATCTGGATAAAGGAAGAAAGCAGGTACAAAAGTCCCTTGCTAAAGCAGAATTTAGAGCAAGGTCCCAACTCTCTTCTATCTTATAAAGGCTGAGAN\t-7-7---A------7--77--))))7--F-A)7F( pairtools split \\\n", + " --output-pairs test.nodups.pairs.gz \\\n", + " --output-sam test.nodups.bam \\\n", + " ) \\\n", + " --output-unmapped \\\n", + " >( pairtools split \\\n", + " --output-pairs test.unmapped.pairs.gz \\\n", + " --output-sam test.unmapped.bam \\\n", + " ) \\\n", + " --output-dups \\\n", + " >( pairtools split \\\n", + " --output-pairs test.dups.pairs.gz \\\n", + " --output-sam test.dups.bam \\\n", + " ) \\\n", + " --output-stats test.dedup.stats \\\n", + " test.pairs.gz" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d9aaceeb-1a88-4c24-9fc2-3f44069715a1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRR13849430.513\tchr20\t23502312\tchr20\t23063544\t+\t+\tRU\t60\t60\n", + "SRR13849430.1442\tchr7\t57224960\tchrX\t82818236\t+\t+\tUU\t60\t30\n", + "SRR13849430.2378\tchr5\t115925933\tchr21\t24124840\t+\t+\tUU\t60\t50\n", + "SRR13849430.2547\tchr1\t52097837\tchr12\t1888807\t-\t-\tUU\t60\t60\n", + "SRR13849430.3015\tchr17\t74750879\tchr11\t117356318\t+\t-\tUR\t60\t60\n", + "SRR13849430.3027\tchr15\t34977762\tchr15\t31897447\t-\t+\tUR\t11\t60\n", + "SRR13849430.3406\tchr11\t1171960\tchr9\t121265592\t+\t-\tUU\t60\t60\n", + "SRR13849430.3988\tchr16\t86824176\tchr13\t104521019\t-\t+\tUU\t60\t17\n", + "SRR13849430.4030\tchr17\t73189645\tchr4\t49092470\t-\t+\tUU\t60\t31\n", + "SRR13849430.4316\tchr8\t124329308\tchr8\t124336541\t-\t-\tUU\t60\t60\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Unique pairs:\n", + "gzip -dc test.nodups.pairs.gz | grep -v \"#\" | head -n 10" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ca3e27a7-7905-46b2-8ad4-245c28f01102", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SRR13849430.60371\tchr2\t44507613\tchr7\t116276932\t-\t+\tDD\t60\t57\n", + "SRR13849430.67567\tchr5\t62425895\tchr5\t62425612\t-\t+\tDD\t60\t60\n", + "SRR13849430.97623\tchr3\t162233323\tchr3\t162154449\t-\t+\tDD\t60\t52\n", + "SRR13849430.108366\tchr8\t48691403\tchr8\t48872239\t-\t-\tDD\t60\t60\n", + "SRR13849430.138622\tchr16\t8435050\tchr16\t6032751\t+\t-\tDD\t60\t60\n", + "SRR13849430.146482\tchr14\t86385083\tchr2\t119648648\t+\t+\tDD\t60\t60\n", + "SRR13849430.148232\tchrX\t21885792\tchrX\t21887418\t+\t-\tDD\t60\t60\n", + "SRR13849430.149771\tchr16\t6646543\tchr16\t6648097\t-\t-\tDD\t60\t60\n", + "SRR13849430.156983\tchr4\t55704089\tchr4\t76039070\t+\t+\tDD\t60\t13\n", + "SRR13849430.157962\tchr6\t47656758\tchr6\t47748395\t+\t-\tDD\t60\t35\n" + ] + } + ], + "source": [ + "%%bash\n", + "# Only duplicated pairs:\n", + "gzip -dc test.dups.pairs.gz | grep -v \"#\" | head -n 10" + ] + }, + { + "cell_type": "markdown", + "id": "7441b723-5c5d-4502-8330-c8b7b4a24e30", + "metadata": {}, + "source": [ + "#### pairtools select\n", + "\n", + "Sometimes you may need certain types of pairs based on their properties, such as mapq, pair type, distance or orientation. \n", + "For all these manipulations, there is `pairtools select` which requires a file and pythonic condition as an input:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3a2de712-b4ef-4ee3-af68-d19f2fa8fb8f", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "pairtools select \"mapq1>0 and mapq2>0\" test.nodups.pairs.gz -o test.nodups.UU.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "1e6445fa-551b-4583-aa61-587a27370fa4", + "metadata": { + "tags": [] + }, + "source": [ + "#### pairtools stats\n", + "\n", + "Describe the types fo distance properties of pairs: " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "3aca9ac8-668b-46c4-a1c2-6172303f284a", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools stats test.pairs.gz -o test.stats" + ] + }, + { + "cell_type": "markdown", + "id": "ca2c1c56-9024-4fa0-abb9-ed1f9ab313f1", + "metadata": {}, + "source": [ + "### MultiQC" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0967edf9-fdf6-4294-98fc-a2c069917de6", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + " /// MultiQC 🔍 | v1.12.dev0 (c3daccb)\n", + "\n", + "| multiqc | Search path : /home/agalicina/Open2C/pairtools_pre1/examples/test.stats\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| searching | ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 1/1 \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "| pairtools | parsing .stats file: test.stats\n", + "| pairtools | Found 1 reports\n", + "/home/agalicina/soft/MultiQC/multiqc/modules/pairtools/pairtools.py:401: RuntimeWarning: invalid value encountered in true_divide\n", + " _summary[cat] = _summary[cat] / _areas\n", + "| multiqc | Compressing plot data\n", + "| megaqc | Couldn't export data key 'report.general_stats_data'\n", + "| multiqc | Previous MultiQC output found! Adjusting filenames..\n", + "| multiqc | Use -f or --force to overwrite existing reports instead\n", + "| multiqc | Report : multiqc_report_4.html\n", + "| multiqc | Data : multiqc_data_4\n", + "| multiqc | MultiQC complete\n" + ] + } + ], + "source": [ + "%%bash\n", + "multiqc test.stats" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "d76bd76c-f0f5-4921-b873-9390e715eab9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "\n", + "IFrame(src='./multiqc_report.html', width=1200, height=700)" + ] + }, + { + "cell_type": "markdown", + "id": "e0dc157d-a8c6-4319-b83c-d450f2a822f3", + "metadata": {}, + "source": [ + "### Load pairs to cooler\n", + "Finally, when you obtained a list of appropriate pairs, you may create coolers with it: " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3d9df0e2-f8d3-487b-8369-cddf8bdd54df", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:py.warnings:/home/agalicina/soft/test/cooler/cooler/util.py:733: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead.\n", + " is_cat = pd.api.types.is_categorical(bins[\"chrom\"])\n", + "\n", + "INFO:cooler.create:Writing chunk 0: /home/agalicina/Open2C/pairtools_pre1/examples/tmp0_0wda3c.multi.cool::0\n", + "INFO:cooler.create:Creating cooler at \"/home/agalicina/Open2C/pairtools_pre1/examples/tmp0_0wda3c.multi.cool::/0\"\n", + "INFO:cooler.create:Writing chroms\n", + "INFO:cooler.create:Writing bins\n", + "INFO:cooler.create:Writing pixels\n", + "INFO:cooler.create:Writing indexes\n", + "INFO:cooler.create:Writing info\n", + "INFO:cooler.create:Merging into test.hg38.1000000.cool\n", + "INFO:cooler.create:Creating cooler at \"test.hg38.1000000.cool::/\"\n", + "INFO:cooler.create:Writing chroms\n", + "INFO:cooler.create:Writing bins\n", + "INFO:cooler.create:Writing pixels\n", + "INFO:cooler.reduce:nnzs: [468683]\n", + "INFO:cooler.reduce:current: [468683]\n", + "INFO:cooler.create:Writing indexes\n", + "INFO:cooler.create:Writing info\n" + ] + } + ], + "source": [ + "%%bash\n", + "cooler cload pairs \\\n", + " -c1 2 -p1 3 -c2 4 -p2 5 \\\n", + " --assembly hg38 \\\n", + " ~/.local/share/genomes/hg38/hg38.fa.sizes:1000000 \\\n", + " test.nodups.UU.pairs.gz \\\n", + " test.hg38.1000000.cool" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "083da222-8d15-408b-ad8c-7fa35881597f", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:cooler.cli.zoomify:Recursively aggregating \"test.hg38.1000000.cool\"\n", + "INFO:cooler.cli.zoomify:Writing to \"test.hg38.1000000.mcool\"\n", + "INFO:cooler.reduce:Copying base matrices and producing 2 new zoom levels.\n", + "INFO:cooler.reduce:Bin size: 1000000\n", + "INFO:cooler.reduce:Aggregating from 1000000 to 2000000.\n", + "WARNING:py.warnings:/home/agalicina/soft/test/cooler/cooler/util.py:733: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead.\n", + " is_cat = pd.api.types.is_categorical(bins[\"chrom\"])\n", + "\n", + "INFO:cooler.create:Creating cooler at \"test.hg38.1000000.mcool::/resolutions/2000000\"\n", + "INFO:cooler.create:Writing chroms\n", + "INFO:cooler.create:Writing bins\n", + "INFO:cooler.create:Writing pixels\n", + "INFO:cooler.reduce:0 468683\n", + "INFO:cooler.create:Writing indexes\n", + "INFO:cooler.create:Writing info\n", + "INFO:cooler.cli.zoomify:Balancing zoom level with bin size 1000000\n", + "INFO:cooler.cli.balance:Balancing \"test.hg38.1000000.mcool::resolutions/1000000\"\n", + "INFO:cooler.balance:variance is 37206.68971415146\n", + "INFO:cooler.balance:variance is 2082.805159204234\n", + "INFO:cooler.balance:variance is 742.7371481963397\n", + "INFO:cooler.balance:variance is 232.9004212087261\n", + "INFO:cooler.balance:variance is 109.95025887479433\n", + "INFO:cooler.balance:variance is 48.86125149222208\n", + "INFO:cooler.balance:variance is 25.959968636995747\n", + "INFO:cooler.balance:variance is 12.88108896709312\n", + "INFO:cooler.balance:variance is 7.01771597546298\n", + "INFO:cooler.balance:variance is 3.64382004424368\n", + "INFO:cooler.balance:variance is 1.9931220263033693\n", + "INFO:cooler.balance:variance is 1.0592807008102647\n", + "INFO:cooler.balance:variance is 0.5797427426283636\n", + "INFO:cooler.balance:variance is 0.31216835609277127\n", + "INFO:cooler.balance:variance is 0.17088960705423364\n", + "INFO:cooler.balance:variance is 0.092713157544345\n", + "INFO:cooler.balance:variance is 0.050768189455505104\n", + "INFO:cooler.balance:variance is 0.027664274174654214\n", + "INFO:cooler.balance:variance is 0.015153085011558797\n", + "INFO:cooler.balance:variance is 0.008278252292230543\n", + "INFO:cooler.balance:variance is 0.004535639594067231\n", + "INFO:cooler.balance:variance is 0.0024815694651605423\n", + "INFO:cooler.balance:variance is 0.0013599466042380605\n", + "INFO:cooler.balance:variance is 0.0007447188932097477\n", + "INFO:cooler.balance:variance is 0.00040818795802218005\n", + "INFO:cooler.balance:variance is 0.00022364381134701224\n", + "INFO:cooler.balance:variance is 0.00012259626540541001\n", + "INFO:cooler.balance:variance is 6.71905676143817e-05\n", + "INFO:cooler.balance:variance is 3.683542358885866e-05\n", + "INFO:cooler.balance:variance is 2.019189009483094e-05\n", + "INFO:cooler.balance:variance is 1.1070311336137434e-05\n", + "INFO:cooler.balance:variance is 6.0690301193834335e-06\n", + "INFO:cooler.cli.zoomify:Balancing zoom level with bin size 2000000\n", + "INFO:cooler.cli.balance:Balancing \"test.hg38.1000000.mcool::resolutions/2000000\"\n", + "INFO:cooler.balance:variance is 71077.3217484595\n", + "INFO:cooler.balance:variance is 3852.0689083633606\n", + "INFO:cooler.balance:variance is 1320.1861010622538\n", + "INFO:cooler.balance:variance is 374.9800275728576\n", + "INFO:cooler.balance:variance is 160.20794099039668\n", + "INFO:cooler.balance:variance is 65.36713717270952\n", + "INFO:cooler.balance:variance is 30.976853027897977\n", + "INFO:cooler.balance:variance is 14.113627305833736\n", + "INFO:cooler.balance:variance is 6.884381806475596\n", + "INFO:cooler.balance:variance is 3.271395099585441\n", + "INFO:cooler.balance:variance is 1.6065843879481463\n", + "INFO:cooler.balance:variance is 0.7776344412062611\n", + "INFO:cooler.balance:variance is 0.38252387366754076\n", + "INFO:cooler.balance:variance is 0.18676463232421997\n", + "INFO:cooler.balance:variance is 0.09191555805208523\n", + "INFO:cooler.balance:variance is 0.045067333675033044\n", + "INFO:cooler.balance:variance is 0.02218435454596555\n", + "INFO:cooler.balance:variance is 0.010900200738585062\n", + "INFO:cooler.balance:variance is 0.005366264412563251\n", + "INFO:cooler.balance:variance is 0.0026394969017164843\n", + "INFO:cooler.balance:variance is 0.001299550183619814\n", + "INFO:cooler.balance:variance is 0.0006395533483206291\n", + "INFO:cooler.balance:variance is 0.00031489899084386077\n", + "INFO:cooler.balance:variance is 0.00015501547108861567\n", + "INFO:cooler.balance:variance is 7.632803644234234e-05\n", + "INFO:cooler.balance:variance is 3.757937885112555e-05\n", + "INFO:cooler.balance:variance is 1.8504092134910213e-05\n", + "INFO:cooler.balance:variance is 9.110981555472034e-06\n" + ] + } + ], + "source": [ + "%%bash\n", + "cooler zoomify \\\n", + " --nproc 5 \\\n", + " --out test.hg38.1000000.mcool \\\n", + " --resolutions 1000000,2000000 \\\n", + " --balance \\\n", + " test.hg38.1000000.cool" + ] + }, + { + "cell_type": "markdown", + "id": "9a17fb3c-d5f8-472e-b80a-e7708798ea72", + "metadata": {}, + "source": [ + "### Visualize coolers:\n", + "\n", + "Based on [open2c vis example](https://github.com/open2c/open2c_examples/blob/master/viz.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1839183d-4d5c-4b29-926c-0d56e00c8b8a", + "metadata": {}, + "outputs": [], + "source": [ + "import cooler\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import cooltools.lib.plotting\n", + "from matplotlib.colors import LogNorm\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "7bae233c-36f2-483c-8957-766e200739a4", + "metadata": {}, + "outputs": [], + "source": [ + "file = \"test.hg38.1000000.mcool::/resolutions/1000000\"" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "2b4cc40b-5aaf-4db8-b870-ba190fdb5d01", + "metadata": {}, + "outputs": [], + "source": [ + "clr = cooler.Cooler(file)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "4350d8c1-b50c-43f7-92e5-43802122320b", + "metadata": {}, + "outputs": [], + "source": [ + "# Define chromosome starts\n", + "chromstarts = []\n", + "for i in clr.chromnames:\n", + " chromstarts.append(clr.extent(i)[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "cd823dec-49c8-46e0-96b6-dcb0344f9d9c", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib.ticker import EngFormatter\n", + "bp_formatter = EngFormatter('b')\n", + "\n", + "def format_ticks(ax, x=True, y=True, rotate=True):\n", + " if y:\n", + " ax.yaxis.set_major_formatter(bp_formatter)\n", + " if x:\n", + " ax.xaxis.set_major_formatter(bp_formatter)\n", + " ax.xaxis.tick_bottom()\n", + " if rotate:\n", + " ax.tick_params(axis='x',rotation=45)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "a0d99510-d5e6-4de5-861b-8eeddcb6c25b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "vmax = 15\n", + "norm = LogNorm(vmin=1, vmax=vmax)\n", + "\n", + "f, axs = plt.subplots(\n", + " figsize=(13, 10),\n", + " nrows=2, \n", + " ncols=1,\n", + " sharex=False, sharey=False)\n", + "\n", + "ax = axs[0]\n", + "ax.set_title('Interaction maps')\n", + "im = ax.matshow(clr.matrix(balance=False).fetch('chr1'), vmax=vmax, cmap='fall'); \n", + "plt.colorbar(im, ax=ax ,fraction=0.046, pad=0.04, label='chr1');\n", + "\n", + "ax = axs[1]\n", + "im = ax.matshow(clr.matrix(balance=False)[:], norm=norm, cmap='fall'); \n", + "plt.colorbar(im, ax=ax ,fraction=0.046, pad=0.04, label='Whole-genome');\n", + "ax.set_xticks(chromstarts,clr.chromnames, rotation=90);\n", + "\n", + "format_ticks(axs[0], rotate=False)\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dc82f6d-8a83-46e0-8deb-ba1166e48cef", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "test", + "language": "python", + "name": "test" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From ec051714240cad32db8adb71977494ecd95710d2 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 19 Apr 2022 14:57:50 -0400 Subject: [PATCH 28/52] example cleanup --- examples/pairtools_walkthrough.ipynb | 868 +-------------------------- 1 file changed, 8 insertions(+), 860 deletions(-) diff --git a/examples/pairtools_walkthrough.ipynb b/examples/pairtools_walkthrough.ipynb index 2eefbf25..8d19e912 100644 --- a/examples/pairtools_walkthrough.ipynb +++ b/examples/pairtools_walkthrough.ipynb @@ -163,719 +163,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "12f8a13d-fba6-45f7-8112-291fb883d7d0", "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - }, "tags": [ "hide-output" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[M::bwa_idx_load_from_disk] read 0 ALT contigs\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (3287, 41601, 3132, 3247)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1474, 3107, 5770)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14362)\n", - "[M::mem_pestat] mean and std.dev: (3761.23, 2688.41)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18658)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (223, 289, 356)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 622)\n", - "[M::mem_pestat] mean and std.dev: (277.40, 91.07)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 755)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1581, 3288, 5799)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14235)\n", - "[M::mem_pestat] mean and std.dev: (3826.54, 2661.54)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18453)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1390, 3033, 5607)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14041)\n", - "[M::mem_pestat] mean and std.dev: (3665.64, 2669.72)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18258)\n", - "[M::mem_process_seqs] Processed 333334 reads in 265.486 CPU sec, 52.960 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4098, 45623, 3818, 4052)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1387, 3097, 5547)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13867)\n", - "[M::mem_pestat] mean and std.dev: (3675.38, 2672.89)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18027)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (249, 315, 384)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 654)\n", - "[M::mem_pestat] mean and std.dev: (302.37, 92.23)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 789)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1521, 3113, 5702)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14064)\n", - "[M::mem_pestat] mean and std.dev: (3765.30, 2673.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18245)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1503, 3159, 5689)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14061)\n", - "[M::mem_pestat] mean and std.dev: (3747.58, 2673.34)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18247)\n", - "[M::mem_process_seqs] Processed 333334 reads in 247.462 CPU sec, 49.313 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4528, 42266, 4055, 4429)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1475, 3117, 5749)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14297)\n", - "[M::mem_pestat] mean and std.dev: (3758.22, 2705.83)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18571)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (256, 326, 400)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 688)\n", - "[M::mem_pestat] mean and std.dev: (310.02, 96.45)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 832)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1550, 3273, 5819)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14357)\n", - "[M::mem_pestat] mean and std.dev: (3856.53, 2696.57)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18626)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1487, 3090, 5637)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13937)\n", - "[M::mem_pestat] mean and std.dev: (3733.20, 2679.28)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18087)\n", - "[M::mem_process_seqs] Processed 333334 reads in 273.826 CPU sec, 54.630 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4076, 37876, 3820, 4047)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1454, 3061, 5610)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13922)\n", - "[M::mem_pestat] mean and std.dev: (3732.19, 2712.64)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18078)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (250, 320, 394)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 682)\n", - "[M::mem_pestat] mean and std.dev: (303.19, 95.64)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 826)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1571, 3307, 5902)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14564)\n", - "[M::mem_pestat] mean and std.dev: (3876.78, 2705.22)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18895)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1447, 3096, 5575)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13831)\n", - "[M::mem_pestat] mean and std.dev: (3720.16, 2684.08)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17959)\n", - "[M::mem_process_seqs] Processed 333334 reads in 345.500 CPU sec, 68.902 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4818, 38154, 4476, 4786)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1450, 3040, 5635)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14005)\n", - "[M::mem_pestat] mean and std.dev: (3690.60, 2666.10)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18190)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 341, 418)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 714)\n", - "[M::mem_pestat] mean and std.dev: (322.66, 97.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 862)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1559, 3229, 5848)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14426)\n", - "[M::mem_pestat] mean and std.dev: (3840.73, 2697.24)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18715)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1469, 3134, 5727)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14243)\n", - "[M::mem_pestat] mean and std.dev: (3761.26, 2703.10)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18501)\n", - "[M::mem_process_seqs] Processed 333334 reads in 269.799 CPU sec, 53.768 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4834, 38078, 4440, 4800)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1456, 3150, 5690)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14158)\n", - "[M::mem_pestat] mean and std.dev: (3764.15, 2683.53)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18392)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 342, 422)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 724)\n", - "[M::mem_pestat] mean and std.dev: (323.77, 98.63)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 875)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1653, 3328, 5869)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14301)\n", - "[M::mem_pestat] mean and std.dev: (3897.71, 2667.65)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18517)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1471, 3102, 5666)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14056)\n", - "[M::mem_pestat] mean and std.dev: (3732.45, 2677.73)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18251)\n", - "[M::mem_process_seqs] Processed 333334 reads in 253.924 CPU sec, 50.629 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4875, 37010, 4449, 4614)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1378, 3026, 5606)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14062)\n", - "[M::mem_pestat] mean and std.dev: (3687.11, 2682.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18290)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (266, 337, 417)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 719)\n", - "[M::mem_pestat] mean and std.dev: (318.07, 98.46)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 870)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1568, 3288, 5861)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14447)\n", - "[M::mem_pestat] mean and std.dev: (3863.33, 2674.78)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18740)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1468, 3112, 5718)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14218)\n", - "[M::mem_pestat] mean and std.dev: (3739.97, 2683.97)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18468)\n", - "[M::mem_process_seqs] Processed 333334 reads in 264.349 CPU sec, 52.728 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4652, 39642, 4342, 4692)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1516, 3202, 5766)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14266)\n", - "[M::mem_pestat] mean and std.dev: (3776.01, 2667.49)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18516)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (266, 337, 414)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 710)\n", - "[M::mem_pestat] mean and std.dev: (318.94, 98.21)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 858)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1611, 3306, 5950)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14628)\n", - "[M::mem_pestat] mean and std.dev: (3898.13, 2691.23)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18967)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1471, 3203, 5777)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14389)\n", - "[M::mem_pestat] mean and std.dev: (3780.94, 2714.60)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18695)\n", - "[M::mem_process_seqs] Processed 333334 reads in 258.878 CPU sec, 51.567 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4608, 41925, 4262, 4812)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1460, 3186, 5655)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14045)\n", - "[M::mem_pestat] mean and std.dev: (3751.99, 2672.33)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18240)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 338, 415)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 707)\n", - "[M::mem_pestat] mean and std.dev: (321.72, 97.93)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 853)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1528, 3118, 5773)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14263)\n", - "[M::mem_pestat] mean and std.dev: (3795.58, 2679.93)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18508)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1468, 3100, 5609)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13891)\n", - "[M::mem_pestat] mean and std.dev: (3713.09, 2649.96)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18032)\n", - "[M::mem_process_seqs] Processed 333334 reads in 220.489 CPU sec, 43.911 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4714, 41099, 4459, 4771)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1491, 3167, 5643)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13947)\n", - "[M::mem_pestat] mean and std.dev: (3747.12, 2659.24)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18099)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 339, 414)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 704)\n", - "[M::mem_pestat] mean and std.dev: (322.29, 97.81)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 849)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1546, 3252, 5927)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14689)\n", - "[M::mem_pestat] mean and std.dev: (3886.54, 2738.49)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 19070)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1426, 3164, 5572)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13864)\n", - "[M::mem_pestat] mean and std.dev: (3698.58, 2657.41)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18010)\n", - "[M::mem_process_seqs] Processed 333334 reads in 210.858 CPU sec, 41.992 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4775, 39374, 4396, 4780)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1464, 3074, 5592)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13848)\n", - "[M::mem_pestat] mean and std.dev: (3707.65, 2664.00)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17976)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (267, 337, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 714)\n", - "[M::mem_pestat] mean and std.dev: (319.82, 98.35)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 863)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1618, 3302, 5726)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13942)\n", - "[M::mem_pestat] mean and std.dev: (3823.36, 2630.95)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18050)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1430, 3071, 5694)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14222)\n", - "[M::mem_pestat] mean and std.dev: (3719.43, 2691.38)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18486)\n", - "[M::mem_process_seqs] Processed 333334 reads in 254.075 CPU sec, 50.583 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4813, 34027, 4527, 4899)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1422, 3076, 5591)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13929)\n", - "[M::mem_pestat] mean and std.dev: (3699.48, 2672.13)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18098)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (264, 336, 421)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 735)\n", - "[M::mem_pestat] mean and std.dev: (315.65, 100.09)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 892)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1502, 3174, 5801)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14399)\n", - "[M::mem_pestat] mean and std.dev: (3824.32, 2717.22)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18698)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1473, 3051, 5637)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13965)\n", - "[M::mem_pestat] mean and std.dev: (3709.03, 2650.64)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18129)\n", - "[M::mem_process_seqs] Processed 333334 reads in 314.042 CPU sec, 62.599 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4683, 37521, 4309, 4624)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1449, 3018, 5700)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14202)\n", - "[M::mem_pestat] mean and std.dev: (3732.67, 2706.81)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18453)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (254, 327, 406)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 710)\n", - "[M::mem_pestat] mean and std.dev: (308.63, 98.92)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 862)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1577, 3305, 5922)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14612)\n", - "[M::mem_pestat] mean and std.dev: (3895.97, 2701.33)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18957)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1421, 3048, 5673)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14177)\n", - "[M::mem_pestat] mean and std.dev: (3710.94, 2690.58)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18429)\n", - "[M::mem_process_seqs] Processed 333334 reads in 305.796 CPU sec, 60.948 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4724, 39109, 4457, 4871)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1480, 3169, 5675)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14065)\n", - "[M::mem_pestat] mean and std.dev: (3776.57, 2679.23)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18260)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 339, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 708)\n", - "[M::mem_pestat] mean and std.dev: (321.97, 97.62)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 854)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1625, 3386, 5961)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14633)\n", - "[M::mem_pestat] mean and std.dev: (3937.19, 2718.89)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18969)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1428, 3008, 5508)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13668)\n", - "[M::mem_pestat] mean and std.dev: (3661.51, 2648.77)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17748)\n", - "[M::mem_process_seqs] Processed 333334 reads in 268.335 CPU sec, 53.461 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4632, 41869, 4485, 4634)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1443, 3079, 5700)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14214)\n", - "[M::mem_pestat] mean and std.dev: (3721.69, 2698.06)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18471)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 338, 415)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 707)\n", - "[M::mem_pestat] mean and std.dev: (321.90, 97.96)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 853)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1575, 3258, 5775)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14175)\n", - "[M::mem_pestat] mean and std.dev: (3853.28, 2687.40)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18375)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1526, 3111, 5616)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13796)\n", - "[M::mem_pestat] mean and std.dev: (3741.15, 2662.65)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17886)\n", - "[M::mem_process_seqs] Processed 333334 reads in 217.740 CPU sec, 43.365 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4757, 42082, 4383, 4763)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1422, 3138, 5627)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14037)\n", - "[M::mem_pestat] mean and std.dev: (3752.31, 2706.08)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18242)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 339, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 710)\n", - "[M::mem_pestat] mean and std.dev: (322.89, 98.48)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 857)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1560, 3269, 5719)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14037)\n", - "[M::mem_pestat] mean and std.dev: (3836.85, 2673.16)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18196)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1431, 3055, 5688)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14202)\n", - "[M::mem_pestat] mean and std.dev: (3719.86, 2683.04)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18459)\n", - "[M::mem_process_seqs] Processed 333334 reads in 211.692 CPU sec, 42.150 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4832, 41867, 4340, 4770)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1450, 3162, 5688)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14164)\n", - "[M::mem_pestat] mean and std.dev: (3755.67, 2689.37)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18402)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 339, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 708)\n", - "[M::mem_pestat] mean and std.dev: (323.23, 97.56)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 854)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1569, 3306, 5850)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14412)\n", - "[M::mem_pestat] mean and std.dev: (3856.27, 2681.74)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18693)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1474, 3135, 5549)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13699)\n", - "[M::mem_pestat] mean and std.dev: (3734.76, 2658.67)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17774)\n", - "[M::mem_process_seqs] Processed 333334 reads in 215.468 CPU sec, 42.893 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4626, 41847, 4449, 4720)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1447, 3070, 5581)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13849)\n", - "[M::mem_pestat] mean and std.dev: (3690.10, 2665.75)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17983)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 339, 414)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 700)\n", - "[M::mem_pestat] mean and std.dev: (322.74, 97.56)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 843)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1643, 3348, 5976)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14642)\n", - "[M::mem_pestat] mean and std.dev: (3935.95, 2697.80)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18975)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1527, 3141, 5617)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13797)\n", - "[M::mem_pestat] mean and std.dev: (3750.98, 2660.80)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17887)\n", - "[M::mem_process_seqs] Processed 333334 reads in 219.798 CPU sec, 43.772 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4673, 42097, 4384, 4723)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1470, 3128, 5616)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13908)\n", - "[M::mem_pestat] mean and std.dev: (3733.50, 2663.09)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18054)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 339, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 706)\n", - "[M::mem_pestat] mean and std.dev: (323.16, 97.91)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 851)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1600, 3363, 5843)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14329)\n", - "[M::mem_pestat] mean and std.dev: (3885.36, 2682.59)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18572)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1471, 3083, 5671)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14071)\n", - "[M::mem_pestat] mean and std.dev: (3728.18, 2664.17)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18271)\n", - "[M::mem_process_seqs] Processed 333334 reads in 224.567 CPU sec, 44.728 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4793, 42230, 4379, 4744)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1492, 3150, 5683)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14065)\n", - "[M::mem_pestat] mean and std.dev: (3752.95, 2683.10)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18256)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 339, 415)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 703)\n", - "[M::mem_pestat] mean and std.dev: (323.89, 97.53)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 847)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1586, 3276, 5828)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14312)\n", - "[M::mem_pestat] mean and std.dev: (3857.78, 2697.12)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18554)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1409, 3046, 5641)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14105)\n", - "[M::mem_pestat] mean and std.dev: (3695.07, 2696.09)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18337)\n", - "[M::mem_process_seqs] Processed 333334 reads in 211.020 CPU sec, 42.018 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4719, 41928, 4310, 4769)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1470, 3198, 5602)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13866)\n", - "[M::mem_pestat] mean and std.dev: (3761.66, 2669.15)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17998)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 338, 414)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 702)\n", - "[M::mem_pestat] mean and std.dev: (322.30, 97.27)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 846)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1598, 3343, 5900)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14504)\n", - "[M::mem_pestat] mean and std.dev: (3906.33, 2701.01)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18806)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1464, 3077, 5735)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14277)\n", - "[M::mem_pestat] mean and std.dev: (3745.32, 2690.15)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18548)\n", - "[M::mem_process_seqs] Processed 333334 reads in 212.977 CPU sec, 42.388 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4621, 42123, 4395, 4787)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1446, 3094, 5642)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14034)\n", - "[M::mem_pestat] mean and std.dev: (3721.84, 2672.50)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18230)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 340, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 706)\n", - "[M::mem_pestat] mean and std.dev: (323.46, 97.83)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 851)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1598, 3322, 5795)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14189)\n", - "[M::mem_pestat] mean and std.dev: (3876.17, 2675.85)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18386)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1443, 3087, 5640)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14034)\n", - "[M::mem_pestat] mean and std.dev: (3721.37, 2681.34)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18231)\n", - "[M::mem_process_seqs] Processed 333334 reads in 221.408 CPU sec, 44.082 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4769, 42161, 4488, 4652)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1504, 3124, 5682)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14038)\n", - "[M::mem_pestat] mean and std.dev: (3759.38, 2687.48)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18216)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 339, 415)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 707)\n", - "[M::mem_pestat] mean and std.dev: (323.19, 97.31)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 853)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1569, 3214, 5796)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14250)\n", - "[M::mem_pestat] mean and std.dev: (3824.50, 2669.49)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18477)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1554, 3210, 5745)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14127)\n", - "[M::mem_pestat] mean and std.dev: (3819.37, 2685.96)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18318)\n", - "[M::mem_process_seqs] Processed 333334 reads in 210.839 CPU sec, 42.009 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4767, 42238, 4407, 4741)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1433, 3042, 5632)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14030)\n", - "[M::mem_pestat] mean and std.dev: (3697.61, 2685.85)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18229)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 340, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 706)\n", - "[M::mem_pestat] mean and std.dev: (323.42, 96.95)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 851)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1615, 3176, 5726)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13948)\n", - "[M::mem_pestat] mean and std.dev: (3806.48, 2637.55)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18059)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1440, 3137, 5654)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14082)\n", - "[M::mem_pestat] mean and std.dev: (3735.62, 2689.66)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18296)\n", - "[M::mem_process_seqs] Processed 333334 reads in 205.276 CPU sec, 40.856 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4639, 41942, 4425, 4765)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1513, 3175, 5682)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14020)\n", - "[M::mem_pestat] mean and std.dev: (3758.03, 2646.24)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18189)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 338, 414)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 700)\n", - "[M::mem_pestat] mean and std.dev: (322.47, 96.65)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 843)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1537, 3128, 5670)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13936)\n", - "[M::mem_pestat] mean and std.dev: (3763.72, 2640.91)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18069)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1491, 3136, 5815)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14463)\n", - "[M::mem_pestat] mean and std.dev: (3792.83, 2726.38)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18787)\n", - "[M::mem_process_seqs] Processed 333334 reads in 209.749 CPU sec, 41.761 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4813, 41230, 4392, 4826)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1457, 3207, 5783)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14435)\n", - "[M::mem_pestat] mean and std.dev: (3779.66, 2706.57)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18761)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 340, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 708)\n", - "[M::mem_pestat] mean and std.dev: (322.80, 98.37)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 854)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1627, 3316, 5738)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13960)\n", - "[M::mem_pestat] mean and std.dev: (3869.51, 2663.52)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18071)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1397, 3014, 5567)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13907)\n", - "[M::mem_pestat] mean and std.dev: (3643.06, 2649.99)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18077)\n", - "[M::mem_process_seqs] Processed 333334 reads in 234.250 CPU sec, 46.639 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4639, 40574, 4460, 4784)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1462, 3188, 5812)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14512)\n", - "[M::mem_pestat] mean and std.dev: (3800.39, 2722.17)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18862)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (271, 340, 416)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 706)\n", - "[M::mem_pestat] mean and std.dev: (322.75, 97.80)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 851)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1638, 3363, 5914)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14466)\n", - "[M::mem_pestat] mean and std.dev: (3942.59, 2707.19)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18742)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1502, 3042, 5571)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13709)\n", - "[M::mem_pestat] mean and std.dev: (3672.41, 2618.09)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17778)\n", - "[M::mem_process_seqs] Processed 333334 reads in 238.652 CPU sec, 47.534 real sec\n", - "[M::process] read 333334 sequences (50000100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4633, 41143, 4409, 4821)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1525, 3182, 5590)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13720)\n", - "[M::mem_pestat] mean and std.dev: (3746.72, 2626.79)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 17785)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 339, 415)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 705)\n", - "[M::mem_pestat] mean and std.dev: (322.28, 98.06)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 850)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1587, 3279, 5867)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14427)\n", - "[M::mem_pestat] mean and std.dev: (3874.69, 2695.19)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18707)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1518, 3091, 5686)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14022)\n", - "[M::mem_pestat] mean and std.dev: (3750.87, 2661.94)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18190)\n", - "[M::mem_process_seqs] Processed 333334 reads in 230.074 CPU sec, 45.823 real sec\n", - "[M::process] read 333314 sequences (49997100 bp)...\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4735, 41469, 4266, 4718)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1425, 3072, 5668)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14154)\n", - "[M::mem_pestat] mean and std.dev: (3741.65, 2691.63)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18397)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (270, 338, 413)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 699)\n", - "[M::mem_pestat] mean and std.dev: (322.19, 97.15)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 842)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1539, 3296, 5840)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14442)\n", - "[M::mem_pestat] mean and std.dev: (3852.85, 2709.91)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18743)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1390, 3069, 5585)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 13975)\n", - "[M::mem_pestat] mean and std.dev: (3686.69, 2683.32)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18170)\n", - "[M::mem_process_seqs] Processed 333334 reads in 209.102 CPU sec, 41.679 real sec\n", - "[M::mem_pestat] # candidate unique pairs for (FF, FR, RF, RR): (4736, 41963, 4208, 4679)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1438, 3149, 5674)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14146)\n", - "[M::mem_pestat] mean and std.dev: (3745.19, 2685.14)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18382)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation FR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (269, 338, 412)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 698)\n", - "[M::mem_pestat] mean and std.dev: (322.54, 97.28)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 841)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RF...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1505, 3198, 5829)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14477)\n", - "[M::mem_pestat] mean and std.dev: (3814.29, 2718.53)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18801)\n", - "[M::mem_pestat] analyzing insert size distribution for orientation RR...\n", - "[M::mem_pestat] (25, 50, 75) percentile: (1442, 3070, 5634)\n", - "[M::mem_pestat] low and high boundaries for computing mean and std.dev: (1, 14018)\n", - "[M::mem_pestat] mean and std.dev: (3732.27, 2696.49)\n", - "[M::mem_pestat] low and high boundaries for proper pairs: (1, 18210)\n", - "[M::mem_process_seqs] Processed 333314 reads in 206.173 CPU sec, 41.230 real sec\n", - "[main] Version: 0.7.17-r1188\n", - "[main] CMD: ./bwa mem -t 5 -SP /home/agalicina/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz\n", - "[main] Real time: 1452.802 sec; CPU: 7235.972 sec\n" - ] - } - ], + "outputs": [], "source": [ "# Map test data:\n", "! bwa mem -t 5 -SP ~/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz > test.bam" @@ -1202,49 +497,14 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "0967edf9-fdf6-4294-98fc-a2c069917de6", "metadata": { "tags": [ "hide-output" ] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - " /// MultiQC 🔍 | v1.12.dev0 (c3daccb)\n", - "\n", - "| multiqc | Search path : /home/agalicina/Open2C/pairtools_pre1/examples/test.stats\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "| searching | ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 1/1 \n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "| pairtools | parsing .stats file: test.stats\n", - "| pairtools | Found 1 reports\n", - "/home/agalicina/soft/MultiQC/multiqc/modules/pairtools/pairtools.py:401: RuntimeWarning: invalid value encountered in true_divide\n", - " _summary[cat] = _summary[cat] / _areas\n", - "| multiqc | Compressing plot data\n", - "| megaqc | Couldn't export data key 'report.general_stats_data'\n", - "| multiqc | Previous MultiQC output found! Adjusting filenames..\n", - "| multiqc | Use -f or --force to overwrite existing reports instead\n", - "| multiqc | Report : multiqc_report_4.html\n", - "| multiqc | Data : multiqc_data_4\n", - "| multiqc | MultiQC complete\n" - ] - } - ], + "outputs": [], "source": [ "%%bash\n", "multiqc test.stats" @@ -1296,40 +556,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "3d9df0e2-f8d3-487b-8369-cddf8bdd54df", "metadata": { "tags": [ "hide-output" ] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:py.warnings:/home/agalicina/soft/test/cooler/cooler/util.py:733: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead.\n", - " is_cat = pd.api.types.is_categorical(bins[\"chrom\"])\n", - "\n", - "INFO:cooler.create:Writing chunk 0: /home/agalicina/Open2C/pairtools_pre1/examples/tmp0_0wda3c.multi.cool::0\n", - "INFO:cooler.create:Creating cooler at \"/home/agalicina/Open2C/pairtools_pre1/examples/tmp0_0wda3c.multi.cool::/0\"\n", - "INFO:cooler.create:Writing chroms\n", - "INFO:cooler.create:Writing bins\n", - "INFO:cooler.create:Writing pixels\n", - "INFO:cooler.create:Writing indexes\n", - "INFO:cooler.create:Writing info\n", - "INFO:cooler.create:Merging into test.hg38.1000000.cool\n", - "INFO:cooler.create:Creating cooler at \"test.hg38.1000000.cool::/\"\n", - "INFO:cooler.create:Writing chroms\n", - "INFO:cooler.create:Writing bins\n", - "INFO:cooler.create:Writing pixels\n", - "INFO:cooler.reduce:nnzs: [468683]\n", - "INFO:cooler.reduce:current: [468683]\n", - "INFO:cooler.create:Writing indexes\n", - "INFO:cooler.create:Writing info\n" - ] - } - ], + "outputs": [], "source": [ "%%bash\n", "cooler cload pairs \\\n", @@ -1342,100 +576,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "083da222-8d15-408b-ad8c-7fa35881597f", "metadata": { "tags": [ "hide-output" ] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:cooler.cli.zoomify:Recursively aggregating \"test.hg38.1000000.cool\"\n", - "INFO:cooler.cli.zoomify:Writing to \"test.hg38.1000000.mcool\"\n", - "INFO:cooler.reduce:Copying base matrices and producing 2 new zoom levels.\n", - "INFO:cooler.reduce:Bin size: 1000000\n", - "INFO:cooler.reduce:Aggregating from 1000000 to 2000000.\n", - "WARNING:py.warnings:/home/agalicina/soft/test/cooler/cooler/util.py:733: FutureWarning: is_categorical is deprecated and will be removed in a future version. Use is_categorical_dtype instead.\n", - " is_cat = pd.api.types.is_categorical(bins[\"chrom\"])\n", - "\n", - "INFO:cooler.create:Creating cooler at \"test.hg38.1000000.mcool::/resolutions/2000000\"\n", - "INFO:cooler.create:Writing chroms\n", - "INFO:cooler.create:Writing bins\n", - "INFO:cooler.create:Writing pixels\n", - "INFO:cooler.reduce:0 468683\n", - "INFO:cooler.create:Writing indexes\n", - "INFO:cooler.create:Writing info\n", - "INFO:cooler.cli.zoomify:Balancing zoom level with bin size 1000000\n", - "INFO:cooler.cli.balance:Balancing \"test.hg38.1000000.mcool::resolutions/1000000\"\n", - "INFO:cooler.balance:variance is 37206.68971415146\n", - "INFO:cooler.balance:variance is 2082.805159204234\n", - "INFO:cooler.balance:variance is 742.7371481963397\n", - "INFO:cooler.balance:variance is 232.9004212087261\n", - "INFO:cooler.balance:variance is 109.95025887479433\n", - "INFO:cooler.balance:variance is 48.86125149222208\n", - "INFO:cooler.balance:variance is 25.959968636995747\n", - "INFO:cooler.balance:variance is 12.88108896709312\n", - "INFO:cooler.balance:variance is 7.01771597546298\n", - "INFO:cooler.balance:variance is 3.64382004424368\n", - "INFO:cooler.balance:variance is 1.9931220263033693\n", - "INFO:cooler.balance:variance is 1.0592807008102647\n", - "INFO:cooler.balance:variance is 0.5797427426283636\n", - "INFO:cooler.balance:variance is 0.31216835609277127\n", - "INFO:cooler.balance:variance is 0.17088960705423364\n", - "INFO:cooler.balance:variance is 0.092713157544345\n", - "INFO:cooler.balance:variance is 0.050768189455505104\n", - "INFO:cooler.balance:variance is 0.027664274174654214\n", - "INFO:cooler.balance:variance is 0.015153085011558797\n", - "INFO:cooler.balance:variance is 0.008278252292230543\n", - "INFO:cooler.balance:variance is 0.004535639594067231\n", - "INFO:cooler.balance:variance is 0.0024815694651605423\n", - "INFO:cooler.balance:variance is 0.0013599466042380605\n", - "INFO:cooler.balance:variance is 0.0007447188932097477\n", - "INFO:cooler.balance:variance is 0.00040818795802218005\n", - "INFO:cooler.balance:variance is 0.00022364381134701224\n", - "INFO:cooler.balance:variance is 0.00012259626540541001\n", - "INFO:cooler.balance:variance is 6.71905676143817e-05\n", - "INFO:cooler.balance:variance is 3.683542358885866e-05\n", - "INFO:cooler.balance:variance is 2.019189009483094e-05\n", - "INFO:cooler.balance:variance is 1.1070311336137434e-05\n", - "INFO:cooler.balance:variance is 6.0690301193834335e-06\n", - "INFO:cooler.cli.zoomify:Balancing zoom level with bin size 2000000\n", - "INFO:cooler.cli.balance:Balancing \"test.hg38.1000000.mcool::resolutions/2000000\"\n", - "INFO:cooler.balance:variance is 71077.3217484595\n", - "INFO:cooler.balance:variance is 3852.0689083633606\n", - "INFO:cooler.balance:variance is 1320.1861010622538\n", - "INFO:cooler.balance:variance is 374.9800275728576\n", - "INFO:cooler.balance:variance is 160.20794099039668\n", - "INFO:cooler.balance:variance is 65.36713717270952\n", - "INFO:cooler.balance:variance is 30.976853027897977\n", - "INFO:cooler.balance:variance is 14.113627305833736\n", - "INFO:cooler.balance:variance is 6.884381806475596\n", - "INFO:cooler.balance:variance is 3.271395099585441\n", - "INFO:cooler.balance:variance is 1.6065843879481463\n", - "INFO:cooler.balance:variance is 0.7776344412062611\n", - "INFO:cooler.balance:variance is 0.38252387366754076\n", - "INFO:cooler.balance:variance is 0.18676463232421997\n", - "INFO:cooler.balance:variance is 0.09191555805208523\n", - "INFO:cooler.balance:variance is 0.045067333675033044\n", - "INFO:cooler.balance:variance is 0.02218435454596555\n", - "INFO:cooler.balance:variance is 0.010900200738585062\n", - "INFO:cooler.balance:variance is 0.005366264412563251\n", - "INFO:cooler.balance:variance is 0.0026394969017164843\n", - "INFO:cooler.balance:variance is 0.001299550183619814\n", - "INFO:cooler.balance:variance is 0.0006395533483206291\n", - "INFO:cooler.balance:variance is 0.00031489899084386077\n", - "INFO:cooler.balance:variance is 0.00015501547108861567\n", - "INFO:cooler.balance:variance is 7.632803644234234e-05\n", - "INFO:cooler.balance:variance is 3.757937885112555e-05\n", - "INFO:cooler.balance:variance is 1.8504092134910213e-05\n", - "INFO:cooler.balance:variance is 9.110981555472034e-06\n" - ] - } - ], + "outputs": [], "source": [ "%%bash\n", "cooler zoomify \\\n", From 08fd8e67490826a41b91c32e268f61edb71afcd2 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Wed, 20 Apr 2022 13:24:41 -0400 Subject: [PATCH 29/52] minor change --- pairtools/pairtools_phase.py | 360 ----------------------------------- 1 file changed, 360 deletions(-) delete mode 100644 pairtools/pairtools_phase.py diff --git a/pairtools/pairtools_phase.py b/pairtools/pairtools_phase.py deleted file mode 100644 index 05698103..00000000 --- a/pairtools/pairtools_phase.py +++ /dev/null @@ -1,360 +0,0 @@ -import sys -import click -import re, fnmatch - -from . import _fileio, _pairsam_format, cli, _headerops, common_io_options - -UTIL_NAME = "pairtools_phase" - - -@cli.command() -@click.argument("pairs_path", type=str, required=False) -@click.option( - "-o", - "--output", - type=str, - default="", - help="output file." - " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." - " By default, the output is printed into stdout.", -) -@click.option( - "--phase-suffixes", - nargs=2, - # type=click.Tuple([str, str]), - help="Phase suffixes (of the chrom names), always a pair.", -) -@click.option( - "--clean-output", - is_flag=True, - help="Drop all columns besides the standard ones and phase1/2", -) -@click.option( - "--tag-mode", - type=click.Choice(["XB", "XA"]), - default="XB", - help="Specifies the mode of bwa reporting." - " XA will parse 'XA', the input should be generated with: --add-columns XA,NM,AS,XS --min-mapq 0" - " XB will parse 'XB' tag, the input should be generated with: --add-columns XB,AS,XS --min-mapq 0 " - " Note that XB tag is added by running bwa with -u tag, present in github version. " - " Both modes report similar results: XB reports 0.002% contacts more for phased data, " - " while XA can report ~1-2% more unphased contacts because its definition multiple mappers is more premissive. ", -) -@click.option( - "--report-scores/--no-report-scores", - is_flag=True, - default=False, - help="Report scores of optional, suboptimal and second suboptimal alignments. " - "NM (edit distance) with --tag-mode XA and AS (alfn score) with --tag-mode XB ", -) -@common_io_options -def phase(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): - """Phase pairs mapped to a diploid genome. - Diploid genome is the genome with two set of the chromosome variants, - where each chromosome has one of two suffixes (phase-suffixes) - corresponding to the genome version (phase-suffixes). - - By default, phasing adds two additional columns with phase 0, 1 or "." (unpahsed). - - Phasing is based on detection of chromosome origin of each mapped fragment. - Three scores are considered: best alignment score (S1), - suboptimal alignment (S2) and second suboptimal alignment (S3) scores. - Each fragment can be: - 1) uniquely mapped and phased (S1>S2>S3, first alignment is the best hit), - 2) uniquely mapped but unphased (S1=S2>S3, cannot distinguish between chromosome variants), - 3) multiply mapped (S1=S2=S3) or unmapped. - - PAIRS_PATH : input .pairs/.pairsam file. If the path ends with .gz or .lz4, the - input is decompressed by bgzip/lz4c. By default, the input is read from stdin. - - """ - phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs) - - -if __name__ == "__main__": - phase() - - -def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): - - instream = ( - _fileio.auto_open( - pairs_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - if pairs_path - else sys.stdin - ) - outstream = ( - _fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout - ) - - header, body_stream = _headerops.get_header(instream) - header = _headerops.append_new_pg(header, ID=UTIL_NAME, PN=UTIL_NAME) - old_column_names = _headerops.extract_column_names(header) - - idx_phase1 = len(old_column_names) - idx_phase2 = len(old_column_names) + 1 - if clean_output: - new_column_names = [ - col for col in old_column_names if col in _pairsam_format.COLUMNS - ] - new_column_idxs = [ - i - for i, col in enumerate(old_column_names) - if col in _pairsam_format.COLUMNS - ] - new_column_idxs += [idx_phase1, idx_phase2] - else: - new_column_names = list(old_column_names) - - new_column_names.append("phase1") - new_column_names.append("phase2") - - if report_scores: - if tag_mode=="XB": - new_column_names.append("S1_1") - new_column_names.append("S1_2") - new_column_names.append("S2_1") - new_column_names.append("S2_2") - new_column_names.append("S3_1") - new_column_names.append("S3_2") - if clean_output: - new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] - elif tag_mode=="XA": - new_column_names.append("M1_1") - new_column_names.append("M1_2") - new_column_names.append("M2_1") - new_column_names.append("M2_2") - new_column_names.append("M3_1") - new_column_names.append("M3_2") - if clean_output: - new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] - header = _headerops._update_header_entry( - header, "columns", " ".join(new_column_names) - ) - - if tag_mode == "XB": - if ( - ("XB1" not in old_column_names) - or ("XB2" not in old_column_names) - or ("AS1" not in old_column_names) - or ("AS2" not in old_column_names) - or ("XS1" not in old_column_names) - or ("XS2" not in old_column_names) - ): - raise ValueError( - "The input pairs file must be parsed with the flag --add-columns XB,AS,XS --min-mapq 0" - ) - - COL_XB1 = old_column_names.index("XB1") - COL_XB2 = old_column_names.index("XB2") - COL_AS1 = old_column_names.index("AS1") - COL_AS2 = old_column_names.index("AS2") - COL_XS1 = old_column_names.index("XS1") - COL_XS2 = old_column_names.index("XS2") - - elif tag_mode == "XA": - if ( - ("XA1" not in old_column_names) - or ("XA2" not in old_column_names) - or ("NM1" not in old_column_names) - or ("NM2" not in old_column_names) - or ("AS1" not in old_column_names) - or ("AS2" not in old_column_names) - or ("XS1" not in old_column_names) - or ("XS2" not in old_column_names) - ): - raise ValueError( - "The input pairs file must be parsed with the flag --add-columns XA,NM,AS,XS --min-mapq 0" - ) - - COL_XA1 = old_column_names.index("XA1") - COL_XA2 = old_column_names.index("XA2") - COL_NM1 = old_column_names.index("NM1") - COL_NM2 = old_column_names.index("NM2") - COL_AS1 = old_column_names.index("AS1") - COL_AS2 = old_column_names.index("AS2") - COL_XS1 = old_column_names.index("XS1") - COL_XS2 = old_column_names.index("XS2") - - outstream.writelines((l + "\n" for l in header)) - - for line in body_stream: - cols = line.rstrip().split(_pairsam_format.PAIRSAM_SEP) - cols.append("!") - cols.append("!") - if report_scores: - for _ in range(6): - cols.append("!") - pair_type = cols[_pairsam_format.COL_PTYPE] - - if cols[_pairsam_format.COL_C1] != _pairsam_format.UNMAPPED_CHROM: - if tag_mode == "XB": - phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XB( - cols[_pairsam_format.COL_C1], - cols[COL_XB1], - int(cols[COL_AS1]), - int(cols[COL_XS1]), - phase_suffixes, - ) - elif tag_mode == "XA": - phase1, chrom_base1, S1_1, S2_1, S3_1 = phase_side_XA( - cols[_pairsam_format.COL_C1], - cols[COL_XA1], - int(cols[COL_AS1]), - int(cols[COL_XS1]), - int(cols[COL_NM1]), - phase_suffixes, - ) - - if not report_scores: - cols[idx_phase1] = phase1 - else: - cols[idx_phase1], cols[idx_phase1+2], cols[idx_phase1+4], cols[idx_phase1+6] \ - = phase1, str(S1_1), str(S2_1), str(S3_1) - cols[_pairsam_format.COL_C1] = chrom_base1 - - if chrom_base1 == "!": - cols[_pairsam_format.COL_C1] = _pairsam_format.UNMAPPED_CHROM - cols[_pairsam_format.COL_P1] = str(_pairsam_format.UNMAPPED_POS) - cols[_pairsam_format.COL_S1] = _pairsam_format.UNMAPPED_STRAND - pair_type = "M" + pair_type[1] - - if cols[_pairsam_format.COL_C2] != _pairsam_format.UNMAPPED_CHROM: - - if tag_mode == "XB": - phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XB( - cols[_pairsam_format.COL_C2], - cols[COL_XB2], - int(cols[COL_AS2]), - int(cols[COL_XS2]), - phase_suffixes, - ) - elif tag_mode == "XA": - phase2, chrom_base2, S1_2, S2_2, S3_2 = phase_side_XA( - cols[_pairsam_format.COL_C2], - cols[COL_XA2], - int(cols[COL_AS2]), - int(cols[COL_XS2]), - int(cols[COL_NM2]), - phase_suffixes, - ) - - if not report_scores: - cols[idx_phase1] = phase2 - else: - cols[idx_phase2], cols[idx_phase2+2], cols[idx_phase2+4], cols[idx_phase2+6] \ - = phase2, str(S1_2), str(S2_2), str(S3_2) - cols[_pairsam_format.COL_C2] = chrom_base2 - - if chrom_base2 == "!": - cols[_pairsam_format.COL_C2] = _pairsam_format.UNMAPPED_CHROM - cols[_pairsam_format.COL_P2] = str(_pairsam_format.UNMAPPED_POS) - cols[_pairsam_format.COL_S2] = _pairsam_format.UNMAPPED_STRAND - pair_type = pair_type[0] + "M" - - cols[_pairsam_format.COL_PTYPE] = pair_type - - if clean_output: - cols = [cols[i] for i in new_column_idxs] - - outstream.write(_pairsam_format.PAIRSAM_SEP.join(cols)) - outstream.write("\n") - - if instream != sys.stdin: - instream.close() - - if outstream != sys.stdout: - outstream.close() - - -def get_chrom_phase(chrom, phase_suffixes): - if chrom.endswith(phase_suffixes[0]): - return "0", chrom[: -len(phase_suffixes[0])] - elif chrom.endswith(phase_suffixes[1]): - return "1", chrom[: -len(phase_suffixes[1])] - else: - return "!", chrom - - -def phase_side_XB(chrom, XB, AS, XS, phase_suffixes): - - phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) - - XBs = [i for i in XB.split(';') if len(i) > 0] - S1, S2, S3 = AS, XS, -1 # -1 if the second hit was not reported - - if AS > XS: # Primary hit has higher score than the secondary - return phase, chrom_base, S1, S2, S3 - - elif len(XBs) >= 1: - if len(XBs) >= 2: - alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS, alt_mapq = XBs[1].split(',') - S3 = int(alt2_AS) - if int(alt2_AS) == XS == AS: - return '!', '!', S1, S2, S3 - - alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS, alt_mapq = XBs[0].split(',') - alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) - - alt_is_homologue = ( - (chrom_base == alt_chrom_base) - and - ( - ((phase == '0') and (alt_phase == '1')) - or - ((phase == '1') and (alt_phase == '0')) - ) - ) - - if alt_is_homologue: - return '.', chrom_base, S1, S2, S3 - - return '!', '!', S1, S2, S3 - - -def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): - - phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) - - XAs = [i for i in XA.split(";") if len(i.strip()) > 0] - if len(XAs) >= 1: - alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") - M1, M2, M3 = NM, int(alt_NM), -1 - else: - M1, M2, M3 = NM, -1, -1 # -1 if the second hit was not reported - - if (AS > XS): # Primary hit has higher score than the secondary - return phase, chrom_base, M1, M2, M3 - - elif len(XAs) >= 1: - - if len(XAs) >= 2: - alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM = XAs[1].split(",") - M3 = int(alt2_NM) - if int(alt2_NM) == int(alt_NM) == NM: - return "!", "!", M1, M2, M3 - - alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") - - alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) - - alt_is_homologue = (chrom_base == alt_chrom_base) and ( - ((phase == "0") and (alt_phase == "1")) - or ((phase == "1") and (alt_phase == "0")) - ) - - if alt_is_homologue: - return ".", chrom_base, M1, M2, M3 - - return "!", "!", M1, M2, M3 From 9c26b51ef4db91d34e85f640d908710ba4576d28 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Mon, 25 Apr 2022 18:26:15 -0400 Subject: [PATCH 30/52] imporant fixes: - cython dedup with no-parent id forgotten counter reset; - sphinx doc update (added pysam); - header warning if empty and error if try to add a field to empy one --- pairtools/lib/dedup.py | 12 +++++++++--- pairtools/lib/dedup_cython.pyx | 1 + pairtools/lib/headerops.py | 19 +++++++++++++++++-- requirements_doc.txt | 3 +++ 4 files changed, 30 insertions(+), 5 deletions(-) diff --git a/pairtools/lib/dedup.py b/pairtools/lib/dedup.py index 452ec584..29cccbbd 100644 --- a/pairtools/lib/dedup.py +++ b/pairtools/lib/dedup.py @@ -99,7 +99,10 @@ def streaming_dedup( t1 = time.time() t = t1 - t0 logger.debug(f"total time: {t}") - logger.debug(f"time per mln pairs: {t/N*1e6}") + if N>0: + logger.debug(f"time per mln pairs: {t/N*1e6}") + else: + logger.debug(f"Processed {N} pairs") def _dedup_stream( @@ -527,8 +530,11 @@ def streaming_dedup_cython( # streaming_dedup is over. t1 = time.time() t = t1 - t0 - print(f"total time: {t}") - print(f"time per mln pairs: {t/N*1e6}") + logger.debug(f"total time: {t}") + if N>0: + logger.debug(f"time per mln pairs: {t/N*1e6}") + else: + logger.debug(f"Processed {N} pairs") def fetchadd(key, mydict): diff --git a/pairtools/lib/dedup_cython.pyx b/pairtools/lib/dedup_cython.pyx index 67a4fbe5..a026e4ca 100644 --- a/pairtools/lib/dedup_cython.pyx +++ b/pairtools/lib/dedup_cython.pyx @@ -90,6 +90,7 @@ cdef class OnlineDuplicateDetector(object): pastidx = self.parent_idxs[:self.low] self.low = 0 return pastrm, pastidx + self.low = 0 return pastrm def _run(self, finish=False): diff --git a/pairtools/lib/headerops.py b/pairtools/lib/headerops.py index 20b11d38..d64c60e9 100644 --- a/pairtools/lib/headerops.py +++ b/pairtools/lib/headerops.py @@ -11,6 +11,8 @@ from . import pairsam_format from .fileio import ParseError +from .._logging import get_logger +logger = get_logger() PAIRS_FORMAT_VERSION = "1.0.0" SEP_COLS = " " @@ -72,14 +74,14 @@ def get_header(instream, comment_char=COMMENT_CHAR, ignore_warning=False): # return header and the instream, advanced to the beginning of the data if len(header)==0 and not ignore_warning: - warnings.warn("Headerless input, please, add the header by `pairtools header generate` or `pairtools header transfer`") + logger.warning("Headerless input, please, add the header by `pairtools header generate` or `pairtools header transfer`") return header, instream def extract_fields(header, field_name, save_rest=False): """ - Extract the specified fields from the pairs header and returns + Extract the specified fields from the pairs header and return a list of corresponding values, even if a single field was found. Additionally, can return the list of intact non-matching entries. """ @@ -156,6 +158,15 @@ def validate_header_cols(stream, header): return validate_cols(stream, header) +def is_empty_header(header): + if len(header)==0: + return True + if not header[0].startswith("##"): + return True + else: + return False + + def extract_chromsizes(header): """ Extract chromosome sizes from header lines. @@ -308,6 +319,8 @@ def insert_samheader_pysam(header, samheader): def mark_header_as_sorted(header): header = copy.deepcopy(header) + if is_empty_header(header): + raise Exception("Input file is not valid .pairs, has no header or is empty.") if not any([l.startswith("#sorted") for l in header]): if header[0].startswith("##"): header.insert(1, "#sorted: chr1-chr2-pos1-pos2") @@ -322,6 +335,8 @@ def mark_header_as_sorted(header): def append_new_pg(header, ID="", PN="", VN=None, CL=None, force=False): header = copy.deepcopy(header) + if is_empty_header(header): + raise Exception("Input file is not valid .pairs, has no header or is empty.") samheader, other_header = extract_fields(header, "samheader", save_rest=True) new_samheader = _add_pg_to_samheader(samheader, ID, PN, VN, CL, force) new_header = insert_samheader(other_header, new_samheader) diff --git a/requirements_doc.txt b/requirements_doc.txt index a4decc70..8133cfa7 100644 --- a/requirements_doc.txt +++ b/requirements_doc.txt @@ -2,5 +2,8 @@ Cython numpy>=1.10 nose>=1.3 click>=6.6 +scipy>=1.7.0 +pandas>=1.3.4 +pysam>=0.15.0 git+https://github.com/golobor/sphinx-click sphinx_rtd_theme From 4e9df8a8a0dc899955872722f74f1681e971441c Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 26 Apr 2022 10:29:30 -0400 Subject: [PATCH 31/52] phasing fix of the phase2 bug --- pairtools/cli/phase.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pairtools/cli/phase.py b/pairtools/cli/phase.py index 5ceec1b2..404adfc5 100644 --- a/pairtools/cli/phase.py +++ b/pairtools/cli/phase.py @@ -251,9 +251,8 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ int(cols[COL_NM2]), phase_suffixes, ) - if not report_scores: - cols[idx_phase1] = phase2 + cols[idx_phase2] = phase2 else: cols[idx_phase2], cols[idx_phase2+2], cols[idx_phase2+4], cols[idx_phase2+6] \ = phase2, str(S1_2), str(S2_2), str(S3_2) From 89ced33e38fc007fee71826d3c8f6bfd011badac Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 26 Apr 2022 12:26:12 -0400 Subject: [PATCH 32/52] walkthrough on phasing. improved walkthrough on parse --- examples/pairtools_phase_walkthrough.ipynb | 563 +++++++++++++++++++++ examples/pairtools_walkthrough.ipynb | 124 +++-- 2 files changed, 633 insertions(+), 54 deletions(-) create mode 100644 examples/pairtools_phase_walkthrough.ipynb diff --git a/examples/pairtools_phase_walkthrough.ipynb b/examples/pairtools_phase_walkthrough.ipynb new file mode 100644 index 00000000..ad0db57d --- /dev/null +++ b/examples/pairtools_phase_walkthrough.ipynb @@ -0,0 +1,563 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "112fe2d5-aaed-4eb1-b3f5-2f5889a9c89f", + "metadata": {}, + "source": [ + "# Pairtools phase walkthrough\n", + "\n", + "Welcome to the pairtools phase walkthrough!\n", + "\n", + "Haplotype-resolved Hi-C is a popular technique that helps you to resolve contacts of homologous chromosomes. \n", + "It relies on a simple idea tha homologous chromosomes have variations (e.g., SNPs) that are inherited together as **haplotypes**. DNA reads in Hi-C will have the SNVs from one of two haplotypes, which can be used to distinguish the contacts on the same chromosome (*cis-homologous*) and contacts connecting two homologs (*trans-homologous*). \n", + "\n", + "The experimental challenge of the haplotype-resolved Hi-C is to increase the number of SNPs that distinguish reads from different chromosomes. This can be dome by mating highly diverged. \n", + "\n", + "- Erceg et al. 2019 create highly heterozygous embryos of *Drosophila* [1] \n", + "- Collombet et al. 2020 create highly polymorphic F1 hybrid embryos obtained by crossing female *Mus musculus domesticus* (C57Bl/6J) with male *Mus musculus castaneus* CAST/EiJ) to resolve structures of individual chromosomes in the zygote and embryos [2] \n", + "- Tan et al. 2018 uses available heterozygous positions to infer the 3D structures of single chromosomes by single-cell variant of the protocol Dip-C [3] \n", + "- Duan et al. use dikaryonic nuclei of fungi with 0.7% heterozygosity [4]" + ] + }, + { + "attachments": { + "62e74fba-c1c1-44b5-a3e2-3699c3cac7ce.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "c3795661-e308-44e6-9b0f-3f0396541250", + "metadata": {}, + "source": [ + "In `pairtools` we implement an approach to resolving haplotypes from Erceg et al. The outline of haplotype-resolved parsing of pairs:\n", + "\n", + "1. [Create the reference genome](#Create-the-reference-genome): create the concatenated reference genomes from two haplotypes. \n", + "\n", + " Usually the SNVs are known and can be obtained in .vsf format. We will incorporate the SNVs by [bcftools](https://samtools.github.io/bcftools/bcftools.html) into the reference and create updated fasta files with haplotype-corrected sequences.\n", + " For each homologue we will add the suffixes that identify the type of homologue (`_hap1` or `_hap2`).\n", + "\n", + "2. Map the Hi-C data to the concatenated reference and parse allowing multimappers (mapq 0). \n", + "\n", + " We will also need the mapper to report two suboptimal alignments (aka the second and the third hit).\n", + " When the Hi-C read is mapped to some location in the genome, it will have the suffix of the homologue reported as part of chromosome name.\n", + " However, the true resolved pairs are not yet known at this step. \n", + " \n", + " See sections:\n", + " \n", + " (i) [Download data](#Download-data)\n", + " \n", + " (ii) [Map data with bwa mem to diploid genome](#Map-data-with-bwa-mem-to-diploid-genome)\n", + " \n", + " (iii) [pairtools parse](#pairtools-parse)\n", + " \n", + "\n", + "3. [pairtools phase](#pairtools-phase): phase the pairs based on the reported suboptimal alignments. \n", + "\n", + " By checking the scores of two suboptimal alignments, we will distinguish the true multi-mappers from unresolved pairs (i.e. cases when the read aligns to the location with no distinguishing SNV).\n", + " Phasing procedure will remove the haplotype suffixes from chromosome names and add extra fields to the .pairs file with:\n", + " \n", + " '.' (non-resolved)\n", + " \n", + " '0' (first haplotype) or \n", + " \n", + " '1' (second haplotype). \n", + " \n", + " \n", + " \n", + " Phasing schema: \n", + " \n", + "![image.png](attachment:62e74fba-c1c1-44b5-a3e2-3699c3cac7ce.png)\n", + "\n", + "\n", + "4. Post-procesing. Do sorting, dedup and stats, as usual. \n", + "\n", + " See sections:\n", + " \n", + " (i) [pairtools dedup](#pairtools-dedup)\n", + " \n", + " (ii) [Stats](#Stats)" + ] + }, + { + "cell_type": "markdown", + "id": "9dc8a020-7c4b-471d-9dfd-a5e346f10a27", + "metadata": {}, + "source": [ + "[1] Erceg, J., AlHaj Abed, J., Goloborodko, A., Lajoie, B. R., Fudenberg, G., Abdennur, N., Imakaev, M., McCole, R. B., Nguyen, S. C., Saylor, W., Joyce, E. F., Senaratne, T. N., Hannan, M. A., Nir, G., Dekker, J., Mirny, L. A., & Wu, C. T. (2019). The genome-wide multi-layered architecture of chromosome pairing in early Drosophila embryos. Nature communications, 10(1), 4486. https://doi.org/10.1038/s41467-019-12211-8\n", + "\n", + "[2] Collombet, S., Ranisavljevic, N., Nagano, T., Varnai, C., Shisode, T., Leung, W., Piolot, T., Galupa, R., Borensztein, M., Servant, N., Fraser, P., Ancelin, K., & Heard, E. (2020). Parental-to-embryo switch of chromosome organization in early embryogenesis. Nature, 580(7801), 142–146. https://doi.org/10.1038/s41586-020-2125-z\n", + "\n", + "[3] Tan, L., Xing, D., Chang, C. H., Li, H., & Xie, X. S. (2018). Three-dimensional genome structures of single diploid human cells. Science (New York, N.Y.), 361(6405), 924–928. https://doi.org/10.1126/science.aat5641\n", + "\n", + "[4] Duan, H., Jones, A. W., Hewitt, T., Mackenzie, A., Hu, Y., Sharp, A., Lewis, D., Mago, R., Upadhyaya, N. M., Rathjen, J. P., Stone, E. A., Schwessinger, B., Figueroa, M., Dodds, P. N., Periyannan, S., & Sperschneider, J. (2022). Physical separation of haplotypes in dikaryons allows benchmarking of phasing accuracy in Nanopore and HiFi assemblies with Hi-C data. Genome biology, 23(1), 84. https://doi.org/10.1186/s13059-022-02658-2\n" + ] + }, + { + "cell_type": "markdown", + "id": "a0b4c550-8168-4780-82e0-1e18493135af", + "metadata": {}, + "source": [ + "We will test on a sample from Collombet et al. 2019 [2], example of mouse single-cell Hi-C on embryos obtained from highly heterozygous parents. We will take some cell from the dataset, GSM3691125_2CSE_70. \n", + "Note that becuase the procedure is not strictly Hi-C, the properties of this dataset may differ from what you may obtain on bulk data. " + ] + }, + { + "cell_type": "markdown", + "id": "5ab026af-fe25-4a70-82ef-52af6fb25371", + "metadata": {}, + "source": [ + "## Create the reference genome\n", + "\n", + "For phasing, map the data to the concatenated genome with two haplotypes. \n", + "Obtaining such genome is not a simple task. You will need a reference genome, and one or two lists of mutations to instroduce to the reference.\n", + "\n", + "#### Download reference genome" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ec0743f-a299-43f0-b568-7e963ed95df8", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "! wget ftp://ftp-mouse.sanger.ac.uk/ref/GRCm38_68.fa" + ] + }, + { + "cell_type": "markdown", + "id": "7683d63a-bc2f-4c49-8371-fd57f4111072", + "metadata": {}, + "source": [ + "#### Download .vcf file with variants" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a347a3b-2ee7-4824-a209-8377edddf640", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "! wget ftp://ftp-mouse.sanger.ac.uk/current_snps/strain_specific_vcfs/CAST_EiJ.mgp.v5.snps.dbSNP142.vcf.gz" + ] + }, + { + "cell_type": "markdown", + "id": "88363fb6-c233-4a07-a208-a5e5a2679038", + "metadata": {}, + "source": [ + "#### Index the variants" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84cebce3-29c6-42df-98bf-5388a51fb268", + "metadata": {}, + "outputs": [], + "source": [ + "! bcftools index CAST_EiJ.mgp.v5.snps.dbSNP142.vcf.gz" + ] + }, + { + "cell_type": "markdown", + "id": "2dd599a0-64f9-4c8b-b78f-8eabf49c052e", + "metadata": {}, + "source": [ + "#### Introduce the variants into the genome\n", + "\n", + "Note that you may select the variants that are only SNPs but not SNVs (deletions/insertions) by using `--include` parameter of `bcftools consensus` (e.g. `--include '(STRLEN(REF)=1) & (STRLEN(ALT[0])=1)'`).\n", + "This will make sure that the genomic coorditates correspond between the haplotypes. \n", + "Correspondence of coordinates is not a requirement, but might be important for downstream analysis. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "848c9fe5-a632-4139-ba56-60871d8d1eb4", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "%%bash\n", + "bcftools consensus --fasta-ref GRCm38_68.fa.gz \\\n", + " --haplotype 1 CAST_EiJ.mgp.v5.snps.dbSNP142.vcf.gz |sed '/^>/ s/$/_hap1/' | bgzip -c > GRCm38_EiJ_snpsonly_hap1.fa.gz\n", + "\n", + "bcftools consensus --fasta-ref GRCm38_68.fa.gz \\\n", + " --haplotype 2 CAST_EiJ.mgp.v5.snps.dbSNP142.vcf.gz |sed '/^>/ s/$/_hap2/' | bgzip -c > GRCm38_EiJ_snpsonly_hap2.fa.gz\n" + ] + }, + { + "cell_type": "markdown", + "id": "dfd7c4cb-31dd-43df-8510-95fd0ff9f78f", + "metadata": {}, + "source": [ + "#### Create the index of concatenated haplotypes" + ] + }, + { + "cell_type": "markdown", + "id": "99d28f6f-b754-4a95-95d5-9e5e51d14571", + "metadata": {}, + "source": [ + "Concatenate the genomes and index them together. Note that [bwa-mem2](https://github.com/bwa-mem2/bwa-mem2) produces [very similar results to bwa mem](https://github.com/open2c/pairtools/discussions/118), while being [x2-3 times faster](https://github.com/bwa-mem2/bwa-mem2#performance). We highly recommend to use it instead of bwa!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92ff8a4f-2115-4131-8c4a-cbd040dcdffb", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "%%bash\n", + "cat GRCm38_EiJ_snpsonly_hap1.fa.gz GRCm38_EiJ_snpsonly_hap2.fa.gz > GRCm38_EiJ_snpsonly.fa.gz\n", + "bwa index GRCm38_EiJ_snpsonly.fa.gz" + ] + }, + { + "cell_type": "markdown", + "id": "22017c7e-71af-4ef3-8237-364402e896fb", + "metadata": {}, + "source": [ + "Generate chromosome sizes file: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69489018-edde-4aa0-b7ac-7c7b4351764c", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "faidx GRCm38_EiJ_snpsonly.fa.gz -i chromsizes > GRCm38_EiJ_snpsonly.chromsizes" + ] + }, + { + "cell_type": "markdown", + "id": "bd264406-be74-4060-9798-e18040c44889", + "metadata": { + "tags": [] + }, + "source": [ + "## Download data\n", + "\n", + "Uncomment the `--minSpotId` and `--maxSpotId` if you want to run the small test instead of full run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f4e310c0-2d16-4e7d-87d7-44feec8e6256", + "metadata": {}, + "outputs": [], + "source": [ + "! fastq-dump SRR8811373 --gzip --split-spot --split-3 # --minSpotId 0 --maxSpotId 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "571e94fb-3dec-4042-9e21-6c39802ed8df", + "metadata": {}, + "outputs": [], + "source": [ + "! ls SRR8811373*.fastq.gz" + ] + }, + { + "cell_type": "markdown", + "id": "2ce00436-bbc7-4241-a41b-12c99c708180", + "metadata": { + "tags": [] + }, + "source": [ + "## Map data with bwa mem to diploid genome\n", + "\n", + "Note that you may use [bwa mem2](https://github.com/bwa-mem2/bwa-mem2), which is x2 times faster. \n", + "It [proved to produce](https://github.com/open2c/pairtools/discussions/118) results very similar to bwa mem.\n", + "\n", + "There are two modes to work with phasing. \n", + "\n", + "1. Github mode with XB bwa tag. This is the most precise algorithm that operates based on alignment scores of optimal alignment (best hit), and two suboptimal ones.\n", + "\n", + " Download and install [bwa](https://github.com/lh3/bwa) from GitHub.\n", + " Map with:\n", + " ```bash\n", + "./bwa/bwa mem -SPu -t 5 mm10_EiJ_snpsonly.fa.gz test.1.fastq.gz test.2.fastq.gz | samtools view -@ 8 -b > mapped.XB.bam\n", + " ```\n", + "\n", + "\n", + "2. Regular mode with XA bwa tag. \n", + "\n", + " This is simplified version that operates on number of mismatches for the suboptimal alignments.\n", + "\n", + " ```bash\n", + "bwa mem -SP -t 5 mm10_EiJ_snpsonly.fa.gz est.1.fastq.gz test.2.fastq.gz | samtools view -@ 8 -b > mapped.XA.bam\n", + " ```\n", + "\n", + "\n", + "We will try the second option for the simplicity: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12f8a13d-fba6-45f7-8112-291fb883d7d0", + "metadata": { + "tags": [ + "hide-output" + ] + }, + "outputs": [], + "source": [ + "%%bash\n", + "bwa mem -SP -t 5 GRCm38_EiJ_snpsonly.fa.gz SRR8811373_1.fastq.gz SRR8811373_2.fastq.gz \\\n", + " | samtools view -@ 8 -b > mapped.XA.bam" + ] + }, + { + "cell_type": "markdown", + "id": "3bce4691-6268-4885-b8e0-1933a561d4b5", + "metadata": {}, + "source": [ + "## pairtools parse\n", + "\n", + "For phasing, we need additional tags and no filtering by mapq.\n", + "\n", + "`--min-mapq` is 1 by default, which removes all multiply mapped sequences. However, we need this information for phasing to distinguish true multiply mapped pairs from pairs mapped to both haplotypes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efc63459-aa2f-44f5-804e-a2346d2b7820", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools parse --add-columns XA,NM,AS,XS --min-mapq 0 --drop-sam --walks-policy all \\\n", + " -c GRCm38_EiJ_snpsonly.chromsizes mapped.XA.bam -o unphased.XA.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "c90ff16b-bb5b-4ceb-8fe3-feeae8ada021", + "metadata": {}, + "source": [ + "## pairtools phase\n", + "\n", + "Phasing will remove the tags \"\\_1\" and \"\\_2\" from chromosome names and add a separate field for the phase:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c8deaee-cb68-4b53-b306-bf223523ab45", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools phase --phase-suffixes _hap1 _hap2 --tag-mode XA --clean-output unphased.XA.pairs.gz -o phased.XA.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "c17443ec-b647-4818-aced-bdc686109396", + "metadata": {}, + "source": [ + "## pairtools dedup\n", + "\n", + "Sort prior to dedup: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6aabbc13-a8d4-43f2-b388-62e7b3b576ab", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools sort phased.XA.pairs.gz --nproc 10 -o phased.sorted.XA.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "84d0442c-ba94-4571-8c89-44067acecb47", + "metadata": {}, + "source": [ + "Deduplication now should take additional columns with phases into account: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9fd3b266-4faa-4fc0-974d-b0ca9bbeb961", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools dedup --mark-dups --extra-col-pair phase1 phase2 \\\n", + " --output-dups - --output-unmapped - --output-stats phased.XA.dedup.stats \\\n", + " -o phased.sorted.XA.nodup.pairs.gz phased.sorted.XA.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "d7ae3575-aef8-4a8b-9707-b37627653ba9", + "metadata": {}, + "source": [ + "Dedup might generate warning that phase columns now contain mixed data types ('.' alongside with 0 and 1). This warning is inherited from reading by reading the pairs file by pandas." + ] + }, + { + "cell_type": "markdown", + "id": "89f9d829-3f79-49b4-b74d-8bca732b8a44", + "metadata": {}, + "source": [ + "## Stats\n", + "\n", + "First, filter different types of reads:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "727a9d2b-5977-4763-81e5-64589c067688", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools select '(phase1==\"0\") and (phase2==\"0\")' phased.sorted.XA.nodup.pairs.gz -o phased.XA.phase0.pairs.gz\n", + "pairtools select '(phase1==\"1\") and (phase2==\"1\")' phased.sorted.XA.nodup.pairs.gz -o phased.XA.phase1.pairs.gz\n", + "pairtools select '(phase1==\".\") or (phase2==\".\")' phased.sorted.XA.nodup.pairs.gz -o phased.XA.unphased.pairs.gz\n", + "pairtools select '(phase1!=phase2) and (phase1!=\".\") and (phase2!=\".\")' phased.sorted.XA.nodup.pairs.gz \\\n", + " -o phased.XA.trans-phase.pairs.gz" + ] + }, + { + "cell_type": "markdown", + "id": "916a5ca1-e549-4501-82d2-8a6e0645b864", + "metadata": {}, + "source": [ + "Calculate stats for these different types:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1172f899-41d6-4ca2-ab21-a283340011f8", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "pairtools stats phased.XA.phase0.pairs.gz -o phased.XA.phase0.stats\n", + "pairtools stats phased.XA.phase1.pairs.gz -o phased.XA.phase1.stats\n", + "pairtools stats phased.XA.unphased.pairs.gz -o phased.XA.unphased.stats\n", + "pairtools stats phased.XA.trans-phase.pairs.gz -o phased.XA.trans-phase.stats" + ] + }, + { + "cell_type": "markdown", + "id": "25fdebb4-24ca-4280-950e-baa9cc92d28e", + "metadata": {}, + "source": [ + "Visualize with multiQC:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9039184f-65a1-43bd-9495-85266fc1fed6", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "multiqc phased.XA.*phase*.stats -o multiqc_report_phasing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ed403d73-7b5f-432b-9e91-e8c70906d31b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import IFrame\n", + "\n", + "IFrame(src='./multiqc_report_phasing/multiqc_report.html', width=1200, height=700)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20e713fe-c962-4d6f-af73-17c21b987a5a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "test", + "language": "python", + "name": "test" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/pairtools_walkthrough.ipynb b/examples/pairtools_walkthrough.ipynb index 8d19e912..97caba46 100644 --- a/examples/pairtools_walkthrough.ipynb +++ b/examples/pairtools_walkthrough.ipynb @@ -3,7 +3,9 @@ { "cell_type": "markdown", "id": "112fe2d5-aaed-4eb1-b3f5-2f5889a9c89f", - "metadata": {}, + "metadata": { + "tags": [] + }, "source": [ "# Pairtools walkthrough\n", "\n", @@ -12,7 +14,23 @@ "Pairtools is a tool for extraction of pairwise contacts out of sequencing chromosomes conformation capture data, such as Hi-C, Micro-C or MC-3C.\n", "Pairtools is used for obtaining .cool files by [distiller](https://github.com/open2c/distiller-nf/blob/master/distiller.nf), and has many more applications (see single-cell walkthrough or phasing walkthrough). \n", "\n", - "Here, we will cover the basic steps from raw reads to .cool file with binned contacts." + "Here, we will cover the basic steps from raw reads to .cool file with binned contacts.\n", + "\n", + "Outline:\n", + "\n", + "- [Download raw data](#Download-raw-data)\n", + "\n", + "- [Install reference genome](#Install-reference-genome)\n", + "\n", + "- [Map data with bwa mem](#Map-data-with-bwa-mem)\n", + "\n", + "- [Extract contacts](#Contacts-extraction)\n", + "\n", + "- [MultiQC]( #MultiQC )\n", + "\n", + "- [Load pairs to cooler](#Load-pairs-to-cooler)\n", + "\n", + "- [Visualize cooler](#Visualize-cooler)" ] }, { @@ -28,45 +46,27 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "f4e310c0-2d16-4e7d-87d7-44feec8e6256", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Read 5000000 spots for SRR13849430\n", - "Written 5000000 spots for SRR13849430\n" - ] - } - ], + "outputs": [], "source": [ "! fastq-dump SRR13849430 --gzip --split-spot --split-3 --minSpotId 0 --maxSpotId 5000000" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "571e94fb-3dec-4042-9e21-6c39802ed8df", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SRR13849430_1.fastq.gz\tSRR8058285_1.fastq.gz\n", - "SRR13849430_2.fastq.gz\tSRR8058285_2.fastq.gz\n" - ] - } - ], + "outputs": [], "source": [ "! ls SRR13849430*.fastq.gz" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "e9fb044d-1ba0-48c7-b40a-99d033518e43", "metadata": {}, "outputs": [ @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "92ff8a4f-2115-4131-8c4a-cbd040dcdffb", "metadata": {}, "outputs": [ @@ -140,8 +140,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "hg38.blacklist.bed.gz hg38.DpnII.bed hg38.fa.fai hg38.gaps.bed README.txt\n", - "hg38_DpnII.bed\t hg38.fa\t hg38.fa.sizes index\n" + "bwa-mem2\t hg38_DpnII.bed hg38.fa\t hg38.fa.sizes index\n", + "hg38.blacklist.bed.gz hg38.DpnII.bed hg38.fa.fai hg38.gaps.bed README.txt\n" ] } ], @@ -186,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "955bcafa-e521-4627-8c8b-94e05e46e6b8", "metadata": {}, "outputs": [ @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "580a5b54-4a69-4759-b994-12ec3fc4f921", "metadata": {}, "outputs": [], @@ -254,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "e96be112-96d6-4c30-9453-c84f5a1b5edd", "metadata": {}, "outputs": [ @@ -278,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "447ca568-4232-4242-80b3-526e6c886e45", "metadata": {}, "outputs": [ @@ -302,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "afcfeeeb-1502-4b45-b614-24af74b70593", "metadata": {}, "outputs": [ @@ -337,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "68c4ff4d-7025-4e3a-917c-365b944fb564", "metadata": {}, "outputs": [], @@ -356,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "24201e7c-1aec-4935-b5be-f7792b6ccb98", "metadata": {}, "outputs": [], @@ -455,7 +455,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "3a2de712-b4ef-4ee3-af68-d19f2fa8fb8f", "metadata": {}, "outputs": [], @@ -478,7 +478,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "3aca9ac8-668b-46c4-a1c2-6172303f284a", "metadata": {}, "outputs": [], @@ -512,7 +512,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "id": "d76bd76c-f0f5-4921-b873-9390e715eab9", "metadata": {}, "outputs": [ @@ -531,10 +531,10 @@ " " ], "text/plain": [ - "" + "" ] }, - "execution_count": 31, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -599,14 +599,14 @@ "id": "9a17fb3c-d5f8-472e-b80a-e7708798ea72", "metadata": {}, "source": [ - "### Visualize coolers:\n", + "### Visualize cooler\n", "\n", "Based on [open2c vis example](https://github.com/open2c/open2c_examples/blob/master/viz.ipynb)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 36, "id": "1839183d-4d5c-4b29-926c-0d56e00c8b8a", "metadata": {}, "outputs": [], @@ -617,12 +617,14 @@ "%matplotlib inline\n", "import cooltools.lib.plotting\n", "from matplotlib.colors import LogNorm\n", - "import seaborn as sns" + "import seaborn as sns\n", + "import bioframe\n", + "import numpy as np" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "id": "7bae233c-36f2-483c-8957-766e200739a4", "metadata": {}, "outputs": [], @@ -632,7 +634,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "id": "2b4cc40b-5aaf-4db8-b870-ba190fdb5d01", "metadata": {}, "outputs": [], @@ -642,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "4350d8c1-b50c-43f7-92e5-43802122320b", "metadata": {}, "outputs": [], @@ -650,12 +652,12 @@ "# Define chromosome starts\n", "chromstarts = []\n", "for i in clr.chromnames:\n", - " chromstarts.append(clr.extent(i)[0])" + " chromstarts.append(clr.extent(i)[0])" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "cd823dec-49c8-46e0-96b6-dcb0344f9d9c", "metadata": {}, "outputs": [], @@ -675,13 +677,25 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 40, + "id": "896235bb-749b-4c2e-95ae-352c91452b24", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the bounds of the continuous fragment of whole-genome interaction map\n", + "chrom_start, chrom_end = clr.chromnames.index('chr3'), clr.chromnames.index('chr6')\n", + "start, end = chromstarts[chrom_start], chromstarts[chrom_end]" + ] + }, + { + "cell_type": "code", + "execution_count": 43, "id": "a0d99510-d5e6-4de5-861b-8eeddcb6c25b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -703,14 +717,16 @@ " sharex=False, sharey=False)\n", "\n", "ax = axs[0]\n", - "ax.set_title('Interaction maps')\n", + "ax.set_title('Interaction maps (chr1)')\n", "im = ax.matshow(clr.matrix(balance=False).fetch('chr1'), vmax=vmax, cmap='fall'); \n", "plt.colorbar(im, ax=ax ,fraction=0.046, pad=0.04, label='chr1');\n", "\n", "ax = axs[1]\n", - "im = ax.matshow(clr.matrix(balance=False)[:], norm=norm, cmap='fall'); \n", + "ax.set_title('Chromosomes 3-5')\n", + "im = ax.matshow(clr.matrix(balance=False)[start:end, start:end], norm=norm, cmap='fall'); \n", "plt.colorbar(im, ax=ax ,fraction=0.046, pad=0.04, label='Whole-genome');\n", - "ax.set_xticks(chromstarts,clr.chromnames, rotation=90);\n", + "ax.set_xticks(np.array(chromstarts[chrom_start:chrom_end])-start, clr.chromnames[chrom_start:chrom_end], rotation=90);\n", + "ax.set_yticks(np.array(chromstarts[chrom_start:chrom_end])-start, clr.chromnames[chrom_start:chrom_end], rotation=90);\n", "\n", "format_ticks(axs[0], rotate=False)\n", "\n", @@ -720,7 +736,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1dc82f6d-8a83-46e0-8deb-ba1166e48cef", + "id": "e07ca165-15ed-459c-af7b-3156de81f935", "metadata": {}, "outputs": [], "source": [] From b8010e7934b22760a3abe51ffcc5b294a924846e Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 26 Apr 2022 16:04:14 -0400 Subject: [PATCH 33/52] headerops get_colnames and viewframe input validation for scalings added. --- pairtools/lib/headerops.py | 19 +++++++++++++++++++ pairtools/lib/scaling.py | 13 ++++++++++++- 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/pairtools/lib/headerops.py b/pairtools/lib/headerops.py index d64c60e9..502e3b83 100644 --- a/pairtools/lib/headerops.py +++ b/pairtools/lib/headerops.py @@ -747,6 +747,25 @@ def append_columns(header, columns): return header +def get_colnames(header): + """ + Get column names of the header, separated by SEP_COLS + + Parameters + ---------- + header: Previous header + + Returns + ------- + List of column names + """ + for i in range(len(header)): + if header[i].startswith("#columns: "): + columns = header[i].split(SEP_COLS)[1:] + return columns + return [] + + def set_columns(header, columns): """ Set columns to the header, separated by SEP_COLS diff --git a/pairtools/lib/scaling.py b/pairtools/lib/scaling.py index b3f1beb2..f3690bbf 100644 --- a/pairtools/lib/scaling.py +++ b/pairtools/lib/scaling.py @@ -2,7 +2,7 @@ import pandas as pd from .regions import assign_regs_c - +import bioframe def geomprog(factor, start=1): yield start @@ -154,7 +154,18 @@ def bins_pairs_by_distance( ) regions = regions[["chrom", "start", "end"]] + assert bioframe.is_viewframe(regions), "Invalid viewframe created from pairs file" + else: + + if not bioframe.is_viewframe(regions): + try: + regions = bioframe.make_viewframe(regions) + except Exception as e: + raise ValueError(f"Provided regions cannot be converted to viewframe, {e}") + + regions = regions[['chrom', 'start', 'end']] + _, region_starts1, region_ends1 = assign_regs( pairs_df.chrom1.values, pairs_df.pos1.values, regions ).T From d07402e5d2e4b55b7296e4d0ca2c3fe43b5efab2 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 26 Apr 2022 16:36:37 -0400 Subject: [PATCH 34/52] scalings docstrings --- pairtools/cli/scaling.py | 2 +- pairtools/lib/scaling.py | 27 +++++++++++++++++++++++++-- 2 files changed, 26 insertions(+), 3 deletions(-) diff --git a/pairtools/cli/scaling.py b/pairtools/cli/scaling.py index 6034cced..2840a131 100644 --- a/pairtools/cli/scaling.py +++ b/pairtools/cli/scaling.py @@ -20,7 +20,7 @@ @click.option( "--view", "--regions", - help="Path to a BED file which defines which regions of the chromosomes to use. " + help="Path to a BED file which defines which regions (viewframe) of the chromosomes to use. " "By default, this is parsed from .pairs header. ", type=str, required=False, diff --git a/pairtools/lib/scaling.py b/pairtools/lib/scaling.py index f3690bbf..d6aed5b3 100644 --- a/pairtools/lib/scaling.py +++ b/pairtools/lib/scaling.py @@ -154,13 +154,16 @@ def bins_pairs_by_distance( ) regions = regions[["chrom", "start", "end"]] - assert bioframe.is_viewframe(regions), "Invalid viewframe created from pairs file" + try: + regions = bioframe.from_any(regions) + except Exception as e: + raise ValueError(f"Invalid viewframe created from pairs file, {e}") else: if not bioframe.is_viewframe(regions): try: - regions = bioframe.make_viewframe(regions) + regions = bioframe.from_any(regions) except Exception as e: raise ValueError(f"Provided regions cannot be converted to viewframe, {e}") @@ -315,6 +318,26 @@ def compute_scaling( nproc_in=1, cmd_in=None, ): + """ + Main function for computing scaling. + + Parameters + ---------- + pairs: pd.DataFrame, stream of fiel paht with pairs. + regions: bioframe viewframe, anything that can serve as input to bioframe.from_any, or None + chromsizes: additional dataframe with chromosome sizes, if different from regions + dist_range: (int, int) tuple with distance ranges that will be split into windows + n_dist_bins: number of logarithmic bins + chunksize: size of chunks for calculations + ignore_trans: bool, ignore trans or not + filter_f: filter function that can be applied to each chunk + nproc_in + cmd_in + + Returns + ------- + + """ dist_bins = geomspace(dist_range[0], dist_range[1], n_dist_bins) From 0b4a6a8aff810c895f604ef0d9352da2cce88a1c Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 26 Apr 2022 16:45:41 -0400 Subject: [PATCH 35/52] bioframe dependency added --- .github/workflows/python-package.yml | 2 +- .travis.yml | 2 +- requirements.txt | 3 ++- requirements_doc.txt | 1 + 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 8b1f19f3..54fffe4b 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -52,7 +52,7 @@ jobs: conda info -a # Create test environment and install deps - conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy yaml + conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy yaml bioframe source activate test-environment pip install click python setup.py build_ext -i diff --git a/.travis.yml b/.travis.yml index 447ce350..c4160eed 100644 --- a/.travis.yml +++ b/.travis.yml @@ -23,7 +23,7 @@ install: - conda info -a # Create test environment and install deps - - conda create -q -n test-environment python=$TRAVIS_PYTHON_VERSION setuptools pip cython numpy pandas nose samtools pysam + - conda create -q -n test-environment python=$TRAVIS_PYTHON_VERSION setuptools pip cython numpy pandas nose samtools pysam bioframe - source activate test-environment - pip install click - python setup.py build_ext -i diff --git a/requirements.txt b/requirements.txt index 53303de4..29f39431 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,4 +6,5 @@ scipy>=1.7.0 pandas>=1.3.4 pysam>=0.15.0 bioframe -pyyaml \ No newline at end of file +pyyaml +bioframe>=0.3.3 \ No newline at end of file diff --git a/requirements_doc.txt b/requirements_doc.txt index 8133cfa7..70403bb0 100644 --- a/requirements_doc.txt +++ b/requirements_doc.txt @@ -7,3 +7,4 @@ pandas>=1.3.4 pysam>=0.15.0 git+https://github.com/golobor/sphinx-click sphinx_rtd_theme +bioframe>=0.3.3 \ No newline at end of file From 2bdac9a2ab0ef5de42d468a31aa9a2de3631bf2c Mon Sep 17 00:00:00 2001 From: Ilya Flyamer Date: Wed, 27 Apr 2022 20:49:15 +0200 Subject: [PATCH 36/52] Add summaries (#105) * Add summaries * Add functions for duplication tile and complexity * Make dedup stats! Co-authored-by: Aleksandra Galitsyna --- .github/workflows/python-package.yml | 6 +- pairtools/__init__.py | 2 +- pairtools/cli/__init__.py | 3 +- pairtools/cli/dedup.py | 36 +++- pairtools/cli/stats.py | 49 ++++- pairtools/lib/dedup.py | 3 +- pairtools/lib/stats.py | 292 +++++++++++++++++++++++---- tests/data/mock.4stats.pairs | 21 ++ tests/test_stats.py | 26 ++- 9 files changed, 374 insertions(+), 64 deletions(-) create mode 100644 tests/data/mock.4stats.pairs diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index 54fffe4b..cb1e04f9 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -3,11 +3,7 @@ name: Python package -on: - push: - branches: [ master ] - pull_request: - branches: [ master ] +on: push jobs: build: diff --git a/pairtools/__init__.py b/pairtools/__init__.py index c534813d..e4aa6788 100644 --- a/pairtools/__init__.py +++ b/pairtools/__init__.py @@ -12,4 +12,4 @@ __version__ = "1.0.0-dev1" -# from . import lib \ No newline at end of file +# from . import lib diff --git a/pairtools/cli/__init__.py b/pairtools/cli/__init__.py index a1d85d81..9f42e44e 100644 --- a/pairtools/cli/__init__.py +++ b/pairtools/cli/__init__.py @@ -142,6 +142,7 @@ def _excepthook(exc_type, value, tb): sys.excepthook = _excepthook + def common_io_options(func): @click.option( "--nproc-in", @@ -200,5 +201,5 @@ def wrapper(*args, **kwargs): sample, filterbycov, header, - scaling + scaling, ) diff --git a/pairtools/cli/dedup.py b/pairtools/cli/dedup.py index 55a3348c..74bfe29a 100644 --- a/pairtools/cli/dedup.py +++ b/pairtools/cli/dedup.py @@ -5,8 +5,8 @@ import ast import pathlib -# from distutils.log import warn -# import warnings +from .._logging import get_logger +logger = get_logger() from ..lib import fileio, pairsam_format, headerops from . import cli, common_io_options @@ -60,7 +60,16 @@ " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." " By default, statistics are not printed.", ) - +@click.option( + "--output-bytile-stats", + type=str, + default="", + help="output file for duplicate statistics." + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, by-tile duplicate statistics are not printed." + " Note that the readID should be provided and contain tile information for this option. ", +) ### Set the dedup method: @click.option( "--max-mismatch", @@ -223,6 +232,7 @@ def dedup( output_dups, output_unmapped, output_stats, + output_bytile_stats, chunksize, carryover, max_mismatch, @@ -260,6 +270,7 @@ def dedup( output_dups, output_unmapped, output_stats, + output_bytile_stats, chunksize, carryover, max_mismatch, @@ -293,6 +304,7 @@ def dedup_py( output_dups, output_unmapped, output_stats, + output_bytile_stats, chunksize, carryover, max_mismatch, @@ -350,8 +362,21 @@ def dedup_py( else None ) + bytile_dups = False + if output_bytile_stats: + out_bytile_stats_stream = fileio.auto_open( + output_bytile_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + bytile_dups = True + if not keep_parent_id: + logger.warning("Force output --parent-readID because --output-bytile-stats provided.") + keep_parent_id = True + # generate empty PairCounter if stats output is requested: - out_stat = PairCounter() if output_stats else None + out_stat = PairCounter(bytile_dups=bytile_dups) if output_stats else None if not output_dups: outstream_dups = None @@ -465,6 +490,9 @@ def dedup_py( if out_stat: out_stat.save(out_stats_stream) + if bytile_dups: + out_stat.save_bytile_dups(out_bytile_stats_stream) + if instream != sys.stdin: instream.close() diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index f1162805..890988b0 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -10,6 +10,8 @@ from ..lib.stats import PairCounter, do_merge +from .._logging import get_logger +logger = get_logger() UTIL_NAME = "pairtools_stats" @@ -40,8 +42,26 @@ default=False, help="Output stats in yaml format instead of table. ", ) +@click.option( + "--bytile-dups/--no-bytile-dups", + default=False, + help="If enabled, will analyse by-tile duplication statistics to estimate" + " library complexity more accurately." + " Requires parent_readID column to be saved by dedup (will be ignored otherwise)" + " Saves by-tile stats into --output_bytile-stats stream, or regular output if --output_bytile-stats is not provided.", +) +@click.option( + "--output-bytile-stats", + default="", + required=False, + help="output file for tile duplicate statistics." + " If file exists, it will be open in the append mode." + " If the path ends with .gz or .lz4, the output is bgzip-/lz4c-compressed." + " By default, by-tile duplicate statistics are not printed." + " Note that the readID and parent_readID should be provided and contain tile information for this option.", +) @common_io_options -def stats(input_path, output, merge, **kwargs): +def stats(input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs): """Calculate pairs statistics. INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. @@ -51,10 +71,15 @@ def stats(input_path, output, merge, **kwargs): The files with paths ending with .gz/.lz4 are decompressed by bgzip/lz4c. """ - stats_py(input_path, output, merge, **kwargs) + + stats_py( + input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs, + ) -def stats_py(input_path, output, merge, **kwargs): +def stats_py( + input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs +): if merge: do_merge(output, input_path, **kwargs) return @@ -74,14 +99,25 @@ def stats_py(input_path, output, merge, **kwargs): nproc=kwargs.get("nproc_out"), command=kwargs.get("cmd_out", None), ) + if bytile_dups and not output_bytile_stats: + output_bytile_stats = outstream + if output_bytile_stats: + bytile_dups = True header, body_stream = headerops.get_header(instream) cols = headerops.extract_column_names(header) + # Check necessary columns for reporting by-tile stats: + if bytile_dups and "parent_readID" not in cols: + logger.warning( + "No 'parent_readID' column in the file, not generating duplicate stats." + ) + bytile_dups = False + # new stats class stuff would come here ... - stats = PairCounter() + stats = PairCounter(bytile_dups=bytile_dups) - # collecting statistics + # Collecting statistics for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): stats.add_pairs_from_dataframe(chunk) @@ -89,6 +125,9 @@ def stats_py(input_path, output, merge, **kwargs): chromsizes = headerops.extract_chromsizes(header) stats.add_chromsizes(chromsizes) + if bytile_dups: + stats.save_bytile_dups(output_bytile_stats) + # save statistics to file ... stats.save(outstream, yaml=kwargs.get("yaml", False)) diff --git a/pairtools/lib/dedup.py b/pairtools/lib/dedup.py index 29cccbbd..a7aac0a9 100644 --- a/pairtools/lib/dedup.py +++ b/pairtools/lib/dedup.py @@ -1,6 +1,5 @@ import numpy as np import pandas as pd -import warnings import scipy.spatial from scipy.sparse import coo_matrix @@ -380,7 +379,7 @@ def streaming_dedup_cython( # take care of empty lines not at the end of the file separately if rawline and (not stripline): - warnings.warn("Empty line detected not at the end of the file") + logger.warning("Empty line detected not at the end of the file") continue if stripline: diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index c42370c9..167ce491 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -1,39 +1,12 @@ import numpy as np +import pandas as pd +from scipy import special from collections.abc import Mapping import sys from . import fileio -def do_merge(output, files_to_merge, **kwargs): - # Parse all stats files. - stats = [] - for stat_file in files_to_merge: - f = fileio.auto_open( - stat_file, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - # use a factory method to instanciate PairCounter - stat = PairCounter.from_file(f) - stats.append(stat) - f.close() - - # combine stats from several files (files_to_merge): - out_stat = sum(stats) - - # Save merged stats. - outstream = fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - - # save statistics to file ... - out_stat.save(outstream) - - if outstream != sys.stdout: - outstream.close() +from .._logging import get_logger +logger = get_logger() class PairCounter(Mapping): @@ -52,7 +25,7 @@ class PairCounter(Mapping): _SEP = "\t" _KEY_SEP = "/" - def __init__(self, min_log10_dist=0, max_log10_dist=9, log10_dist_bin_step=0.25): + def __init__(self, min_log10_dist=0, max_log10_dist=9, log10_dist_bin_step=0.25, bytile_dups=False): self._stat = {} # some variables used for initialization: # genomic distance bining for the ++/--/-+/+- distribution @@ -99,6 +72,29 @@ def __init__(self, min_log10_dist=0, max_log10_dist=9, log10_dist_bin_step=0.25) "++": np.zeros(len(self._dist_bins), dtype=np.int), } + # Summaries are derived from other stats and are recalculated on merge + self._stat["summary"] = dict( + [ + ("frac_cis", 0), + ("frac_cis_1kb+", 0), + ("frac_cis_2kb+", 0), + ("frac_cis_4kb+", 0), + ("frac_cis_10kb+", 0), + ("frac_cis_20kb+", 0), + ("frac_cis_40kb+", 0), + ("frac_dups", 0), + ("complexity_naive", 0), + ] + ) + self._save_bytile_dups = bytile_dups + if self._save_bytile_dups: + self._bytile_dups = pd.DataFrame( + index=pd.MultiIndex( + levels=[[], []], codes=[[], []], names=["tile", "parent_tile"] + ) + ) + self._summaries_calculated = False + def __getitem__(self, key): if isinstance(key, str): # let's strip any unintentional '/' @@ -179,6 +175,54 @@ def __iter__(self): def __len__(self): return len(self._stat) + def calculate_summaries(self): + """calculate summary statistics (fraction of cis pairs at different cutoffs, + complexity estimate) based on accumulated counts. Results are saved into + self._stat['summary'] + """ + + self._stat["summary"]["frac_dups"] = ( + (self._stat["total_dups"] / self._stat["total_mapped"]) + if self._stat["total_mapped"] > 0 + else 0 + ) + + for cis_count in ( + "cis", + "cis_1kb+", + "cis_2kb+", + "cis_4kb+", + "cis_10kb+", + "cis_20kb+", + "cis_40kb+", + ): + self._stat["summary"][f"frac_{cis_count}"] = ( + (self._stat[cis_count] / self._stat["total_nodups"]) + if self._stat["total_nodups"] > 0 + else 0 + ) + + self._stat["summary"]["complexity_naive"] = estimate_library_complexity( + self._stat["total_mapped"], self._stat["total_dups"], 0 + ) + + if self._save_bytile_dups: + # Estimate library complexity with information by tile, if provided: + if self._bytile_dups.shape[0] > 0: + self._stat["dups_by_tile_median"] = ( + self._bytile_dups["dup_count"].median() * self._bytile_dups.shape[0] + ) + if "dups_by_tile_median" in self._stat.keys(): + self._stat["summary"][ + "complexity_dups_by_tile_median" + ] = estimate_library_complexity( + self._stat["total_mapped"], + self._stat["total_dups"], + self._stat["dups_by_tile_median"], + ) + + self._summaries_calculated = True + @classmethod def from_file(cls, file_handle): """create instance of PairCounter from file @@ -346,7 +390,7 @@ def add_pair(self, chrom1, pos1, strand1, chrom2, pos2, strand2, pair_type): def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): """Gather statistics for Hi-C pairs in a dataframe and add to the PairCounter. - + Parameters ---------- df: pd.DataFrame @@ -385,22 +429,25 @@ def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): mask_dups = df_mapped["duplicate"] else: mask_dups = df_mapped["pair_type"] == "DD" - dups_count = mask_dups.sum() + df_dups = df_mapped[mask_dups] + dups_count = df_dups.shape[0] self._stat["total_dups"] += int(dups_count) self._stat["total_nodups"] += int(mapped_count - dups_count) + df_nodups = df_mapped.loc[~mask_dups, :] + mask_cis = df_nodups["chrom1"] == df_nodups["chrom2"] + df_cis = df_nodups.loc[mask_cis, :].copy() + # Count pairs per chromosome: for (chrom1, chrom2), chrom_count in ( - df_mapped[["chrom1", "chrom2"]].value_counts().items() + df_nodups[["chrom1", "chrom2"]].value_counts().items() ): self._stat["chrom_freq"][(chrom1, chrom2)] = ( self._stat["chrom_freq"].get((chrom1, chrom2), 0) + chrom_count ) # Count cis-trans by pairs: - df_nodups = df_mapped.loc[~mask_dups, :] - mask_cis = df_nodups["chrom1"] == df_nodups["chrom2"] - df_cis = df_nodups.loc[mask_cis, :].copy() + self._stat["cis"] += df_cis.shape[0] self._stat["trans"] += df_nodups.shape[0] - df_cis.shape[0] dist = np.abs(df_cis["pos2"].values - df_cis["pos1"].values) @@ -417,6 +464,13 @@ def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): self._stat["cis_20kb+"] += int(np.sum(dist >= 20000)) self._stat["cis_40kb+"] += int(np.sum(dist >= 40000)) + ### Add by-tile dups + if self._save_bytile_dups and (df_dups.shape[0] > 0): + bytile_dups = analyse_bytile_duplicate_stats(df_dups) + self._bytile_dups = self._bytile_dups.add( + bytile_dups, fill_value=0 + ).astype(int) + def add_chromsizes(self, chromsizes): """ Add chromsizes field to the output stats @@ -524,6 +578,13 @@ def flatten(self): ) # store key,value pair: flat_stat[formatted_key] = freq + elif (k == "summary") and v: + for key, frac in v.items(): + formatted_key = self._KEY_SEP.join(["{}", "{}"]).format( + k, key + ) + # store key,value pair: + flat_stat[formatted_key] = frac # return flattened dict return flat_stat @@ -551,7 +612,9 @@ def format(self): for dirs, freqs in v.items(): # last bin is treated differently: "100000+" vs "1200-3000": if i != len(self._dist_bins) - 1: - dist = "{}-{}".format(self._dist_bins[i], self._dist_bins[i + 1]) + dist = "{}-{}".format( + self._dist_bins[i], self._dist_bins[i + 1] + ) else: dist = "{}+".format(self._dist_bins[i]) if dist not in freqs_dct.keys(): @@ -568,14 +631,20 @@ def format(self): elif (k == "chrom_freq") and v: freqs = {} for (chrom1, chrom2), freq in v.items(): - freqs[self._KEY_SEP.join(["{}", "{}"]).format(chrom1, chrom2)] = freq + freqs[ + self._KEY_SEP.join(["{}", "{}"]).format(chrom1, chrom2) + ] = freq # store key,value pair: formatted_stat[k] = deepcopy(freqs) + elif (k == "summary") and v: + summary_stats = {} + for key, frac in v.items(): + summary_stats[key] = frac + formatted_stat[k] = deepcopy(summary_stats) # return formatted dict return formatted_stat - def save(self, outstream, yaml=False): """save PairCounter to tab-delimited text file. Flattened version of PairCounter is stored in the file. @@ -595,11 +664,152 @@ def save(self, outstream, yaml=False): sort(merge(A,merge(B,C))) == sort(merge(merge(A,B),C)) """ + if not self._summaries_calculated: + self.calculate_summaries() + # write flattened version of the PairCounter to outstream if yaml: import yaml + data = self.format() yaml.dump(data, outstream, default_flow_style=False) else: for k, v in self.flatten().items(): outstream.write("{}{}{}\n".format(k, self._SEP, v)) + + def save_bytile_dups(self, outstream): + """save bytile duplication counts to a tab-delimited text file. + Parameters + ---------- + outstream: file handle + """ + if self._save_bytile_dups: + self._bytile_dups.reset_index().to_csv(outstream, sep="\t", index=False) + else: + logger.error("Bytile dups are not calculated, cannot save.") + + +################## +# Other functions: + +def do_merge(output, files_to_merge, **kwargs): + # Parse all stats files. + stats = [] + for stat_file in files_to_merge: + f = fileio.auto_open( + stat_file, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), + ) + # use a factory method to instanciate PairCounter + stat = PairCounter.from_file(f) + stats.append(stat) + f.close() + + # combine stats from several files (files_to_merge): + out_stat = sum(stats) + + # Save merged stats. + outstream = fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), + ) + + # save statistics to file ... + out_stat.save(outstream) + + if outstream != sys.stdout: + outstream.close() + + +def estimate_library_complexity(nseq, ndup, nopticaldup=0): + """Estimate library complexity accounting for optical/clustering duplicates + Parameters + ---------- + nseq : int + Total number of sequences + ndup : int + Total number of duplicates + nopticaldup : int, optional + Number of non-PCR duplicates, by default 0 + Returns + ------- + float + Estimated complexity + """ + nseq = nseq - nopticaldup + if nseq == 0: + logger.warning("Empty of fully duplicated library, can't estimate complexity") + return 0 + ndup = ndup - nopticaldup + u = (nseq - ndup) / nseq + if u==0: + logger.warning("All the sequences are duplicates. Do you run complexity estimation on duplicates file?") + return 0 + seq_to_complexity = special.lambertw(-np.exp(-1 / u) / u).real + 1 / u + complexity = float(nseq / seq_to_complexity) # clean np.int64 data type + return complexity + + +def analyse_bytile_duplicate_stats(df_dups, tile_dup_regex=False): + """Count by-tile duplicates + Parameters + ---------- + dups : pd.DataFrame + Dataframe with duplicates that contains pared read IDs + tile_dup_regex : bool, optional + See extract_tile_info for details, by default False + Returns + ------- + pd.DataFrame + Grouped multi-indexed dataframe of pairwise by-tile duplication counts + """ + + df_dups = df_dups.copy() + + df_dups["tile"] = extract_tile_info(df_dups["readID"], regex=tile_dup_regex) + df_dups["parent_tile"] = extract_tile_info(df_dups["parent_readID"], regex=tile_dup_regex) + + df_dups["same_tile"] = (df_dups["tile"] == df_dups["parent_tile"]) + bytile_dups = ( + df_dups.groupby(["tile", "parent_tile"]) + .size() + .reset_index(name="dup_count") + .sort_values(["tile", "parent_tile"]) + ) + bytile_dups[["tile", "parent_tile"]] = np.sort( + bytile_dups[["tile", "parent_tile"]].values, axis=1 + ) + bytile_dups = bytile_dups.groupby(["tile", "parent_tile"]).sum() + return bytile_dups + + +def extract_tile_info(series, regex=False): + """Extract the name of the tile for each read name in the series + Parameters + ---------- + series : pd.Series + Series containing read IDs + regex : bool, optional + Regex to extract fields from the read IDs that correspond to tile IDs. + By default False, uses a faster predefined approach for typical Illumina + read names + Example: r"(?:\w+):(?:\w+):(\w+):(\w+):(\w+):(?:\w+):(?:\w+)" + Returns + ------- + Series + Series containing tile IDs as strings + """ + if regex: + split = series.str.extractall(regex).unstack().droplevel(1, axis=1) + if split.shape[1]<4: + raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") + return split[0] + ":" + split[1] + ":" + split[2] + else: + split = series.str.split(":", expand=True) + if split.shape[1]<5: + raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") + return split[2] + ":" + split[3] + ":" + split[4] diff --git a/tests/data/mock.4stats.pairs b/tests/data/mock.4stats.pairs new file mode 100644 index 00000000..73c46673 --- /dev/null +++ b/tests/data/mock.4stats.pairs @@ -0,0 +1,21 @@ +## pairs format v1.0.0 +#shape: upper triangle +#genome_assembly: unknown +#samheader: @SQ SN:chr1 LN:100 +#samheader: @SQ SN:chr2 LN:100 +#samheader: @SQ SN:chr3 LN:100 +#samheader: @PG ID:bwa PN:bwa VN:0.7.15-r1140 CL:bwa mem -SP /path/ucsc.hg19.fasta.gz /path/1.fastq.gz /path/2.fastq.gz +#chromosomes: chr2 chr3 chr1 +#chromsize: chr2 100 +#chromsize: chr3 100 +#chromsize: chr1 100 +#columns: readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type +readid01 chr1 1 chr1 50 + + UU +readid02 chr1 1 chr1 50 + + DD +readid03 chr1 1 chr1 2 + + UU +readid04 chr1 1 chr1 3 + + UR +readid05 chr1 1 chr2 20 + + UU +readid06 chr2 1 chr3 2 + + UU +readid07 ! 0 chr1 3 - + NU +readid08 ! 0 chr1 3 - + MU +readid09 ! 0 ! 0 - - WW diff --git a/tests/test_stats.py b/tests/test_stats.py index 344ef56f..d3d6c985 100644 --- a/tests/test_stats.py +++ b/tests/test_stats.py @@ -3,12 +3,13 @@ import sys import subprocess from nose.tools import assert_raises +import numpy as np testdir = os.path.dirname(os.path.realpath(__file__)) def test_mock_pairsam(): - mock_pairsam_path = os.path.join(testdir, "data", "mock.pairsam") + mock_pairsam_path = os.path.join(testdir, "data", "mock.4stats.pairs") try: result = subprocess.check_output( ["python", "-m", "pairtools", "stats", mock_pairsam_path], @@ -25,12 +26,16 @@ def test_mock_pairsam(): ) for k in stats: - stats[k] = int(stats[k]) + try: + stats[k] = int(stats[k]) + except ValueError: + stats[k] = float(stats[k]) print(stats) - assert stats["total"] == 8 + assert stats["total"] == 9 assert stats["total_single_sided_mapped"] == 2 - assert stats["total_mapped"] == 5 + assert stats["total_mapped"] == 6 + assert stats["total_dups"] == 1 assert stats["cis"] == 3 assert stats["trans"] == 2 assert stats["pair_types/UU"] == 4 @@ -38,6 +43,7 @@ def test_mock_pairsam(): assert stats["pair_types/WW"] == 1 assert stats["pair_types/UR"] == 1 assert stats["pair_types/MU"] == 1 + assert stats["pair_types/DD"] == 1 assert stats["chrom_freq/chr1/chr2"] == 1 assert stats["chrom_freq/chr1/chr1"] == 3 assert stats["chrom_freq/chr2/chr3"] == 1 @@ -47,7 +53,17 @@ def test_mock_pairsam(): if k.startswith("dist_freq") and k not in ["dist_freq/1-2/++", "dist_freq/2-3/++", "dist_freq/32-56/++"] ) - + assert stats["dist_freq/1-2/++"] == 1 + assert stats["dist_freq/2-3/++"] == 1 + assert stats["dist_freq/32-56/++"] == 1 + assert stats["summary/frac_cis"] == 0.6 + assert stats["summary/frac_cis_1kb+"] == 0 + assert stats["summary/frac_cis_2kb+"] == 0 + assert stats["summary/frac_cis_4kb+"] == 0 + assert stats["summary/frac_cis_10kb+"] == 0 + assert stats["summary/frac_cis_20kb+"] == 0 + assert stats["summary/frac_cis_40kb+"] == 0 + assert np.isclose(stats["summary/frac_dups"], 1 / 6) assert stats["dist_freq/1-2/++"] == 1 assert stats["dist_freq/2-3/++"] == 1 assert stats["dist_freq/32-56/++"] == 1 From 32f339131a05bbc2e7be42ba9e0653b536e2d7b3 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Wed, 27 Apr 2022 15:12:55 -0400 Subject: [PATCH 37/52] PairCounter merge fix --- pairtools/lib/stats.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 167ce491..9209a605 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -226,11 +226,9 @@ def calculate_summaries(self): @classmethod def from_file(cls, file_handle): """create instance of PairCounter from file - Parameters ---------- file_handle: file handle - Returns ------- PairCounter @@ -245,7 +243,7 @@ def from_file(cls, file_handle): continue if len(fields) != 2: # expect two _SEP separated values per line: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file".format(file_handle.name) ) # extract key and value, then split the key: @@ -257,22 +255,25 @@ def from_file(cls, file_handle): if key in stat_from_file._stat: stat_from_file._stat[key] = int(fields[1]) else: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) ) else: - # in this case key must be in ['pair_types','chrom_freq','dist_freq','dedup'] + # in this case key must be in ['pair_types','chrom_freq','dist_freq','dedup', 'summary'] # get the first 'key' and keep the remainders in 'key_fields' key = key_fields.pop(0) - if key in ["pair_types", "dedup"]: + if key in ["pair_types", "dedup", "summary"]: # assert there is only one element in key_fields left: # 'pair_types' and 'dedup' treated the same if len(key_fields) == 1: - stat_from_file._stat[key][key_fields[0]] = int(fields[1]) + try: + stat_from_file._stat[key][key_fields[0]] = int(fields[1]) + except ValueError: + stat_from_file._stat[key][key_fields[0]] = float(fields[1]) else: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file: {} section implies 1 identifier".format( file_handle.name, key ) @@ -283,7 +284,7 @@ def from_file(cls, file_handle): if len(key_fields) == 2: stat_from_file._stat[key][tuple(key_fields)] = int(fields[1]) else: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) @@ -312,13 +313,13 @@ def from_file(cls, file_handle): # store corresponding value: stat_from_file._stat[key][dirs][bin_idx] = int(fields[1]) else: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) ) else: - raise fileio.ParseError( + raise _fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) @@ -499,7 +500,7 @@ def __add__(self, other): sum_stat._stat[k] = self._stat[k] + other._stat[k] # sum nested dicts/arrays in a context dependet manner: else: - if k in ["pair_types", "dedup"]: + if k in ["pair_types", "dedup", "summary"]: # handy function for summation of a pair of dicts: # https://stackoverflow.com/questions/10461531/merge-and-sum-of-two-dictionaries sum_dicts = lambda dict_x, dict_y: { @@ -528,7 +529,7 @@ def __add__(self, other): return sum_stat # we need this to be able to sum(list_of_PairCounters) - def __read__(self, other): + def __radd__(self, other): if other == 0: return self else: @@ -724,7 +725,6 @@ def do_merge(output, files_to_merge, **kwargs): if outstream != sys.stdout: outstream.close() - def estimate_library_complexity(nseq, ndup, nopticaldup=0): """Estimate library complexity accounting for optical/clustering duplicates Parameters From 78fc54a969d0a658c0d139843bc030e21546d49e Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Wed, 27 Apr 2022 15:16:16 -0400 Subject: [PATCH 38/52] stats forgotten _fileio fix --- pairtools/lib/stats.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 9209a605..dac60066 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -243,7 +243,7 @@ def from_file(cls, file_handle): continue if len(fields) != 2: # expect two _SEP separated values per line: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file".format(file_handle.name) ) # extract key and value, then split the key: @@ -255,7 +255,7 @@ def from_file(cls, file_handle): if key in stat_from_file._stat: stat_from_file._stat[key] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) @@ -273,7 +273,7 @@ def from_file(cls, file_handle): except ValueError: stat_from_file._stat[key][key_fields[0]] = float(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 1 identifier".format( file_handle.name, key ) @@ -284,7 +284,7 @@ def from_file(cls, file_handle): if len(key_fields) == 2: stat_from_file._stat[key][tuple(key_fields)] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) @@ -313,13 +313,13 @@ def from_file(cls, file_handle): # store corresponding value: stat_from_file._stat[key][dirs][bin_idx] = int(fields[1]) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: {} section implies 2 identifiers".format( file_handle.name, key ) ) else: - raise _fileio.ParseError( + raise fileio.ParseError( "{} is not a valid stats file: unknown field {} detected".format( file_handle.name, key ) From 40dd81c989a2fce9674ee27e96a08f1995e1d659 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Wed, 27 Apr 2022 15:28:05 -0400 Subject: [PATCH 39/52] R1/2 substituted with R1-2; docs improved --- doc/_static/rescue_modes.svg | 160 ++++++++++++++++++++-------------- doc/formats.rst | 2 +- doc/parsing.rst | 2 +- pairtools/lib/parse.py | 18 ++-- tests/data/mock.parse-all.sam | 94 ++++++++++---------- tests/data/mock.parse2.sam | 94 ++++++++++---------- 6 files changed, 201 insertions(+), 169 deletions(-) diff --git a/doc/_static/rescue_modes.svg b/doc/_static/rescue_modes.svg index 491a5694..8eafb54a 100644 --- a/doc/_static/rescue_modes.svg +++ b/doc/_static/rescue_modes.svg @@ -1,8 +1,8 @@ - Group 2 + rescue_modes - + @@ -10,9 +10,9 @@ - + - + @@ -28,11 +28,11 @@ - + - - + + 2 @@ -44,9 +44,9 @@ - + - + @@ -62,16 +62,16 @@ - + - - - + + + @@ -108,39 +108,53 @@ - - UU - + + + UU + + - - all - + + + all + + - - mask - + + + mask + + - - 5any, 5unique - + + + 5any, 5unique + + - - --walks-policy - + + + --walks-policy + + - - walk_pair_index - + + + walk_pair_index + + - - 1 - + + + 1 + + @@ -150,56 +164,74 @@ - - - R1/2 + + + R1-2 - - walk_pair_type - + + + walk_pair_type + + - - R1 - + + + R1 + + - - UU - + + + UU + + - - 3any, 3unique - + + + 3any, 3unique + + - - UU - + + + UU + + - - WW - + + + WW + + - - ! - + + + ! + + - - ! - + + + ! + + - - { - + + + { + + diff --git a/doc/formats.rst b/doc/formats.rst index a972db7c..8ca364d4 100644 --- a/doc/formats.rst +++ b/doc/formats.rst @@ -48,7 +48,7 @@ Pairtools' flavor of .pairs .pairs files produced by `pairtools` extend .pairs format in a few ways. -1. `pairtools` store null/ambiguous/chimeric alignments as chrom='!', pos=0, strand='-'. +1. `pairtools` store null, unmapped, ambiguous (multiply mapped) and chimeric (if not parsed by `parse2` or `--walks-policy all` of `parse`) alignments as chrom='!', pos=0, strand='-'. #. `pairtools` store the header of the source .sam files in the '#samheader:' fields of the pairs header. When multiple .pairs files are merged, diff --git a/doc/parsing.rst b/doc/parsing.rst index 17475af3..2542a809 100644 --- a/doc/parsing.rst +++ b/doc/parsing.rst @@ -272,7 +272,7 @@ a separate column of .pair file when setting ``--add-pair-index`` option. - ``walk_pair_index`` contains information on the order of the pair in the recovered walk, starting from 5'-end of left read - ``walk_pair_type`` describes the type of the pair relative to R1 and R2 reads of paired-end sequencing: - - "R1/2" - unconfirmed pair, right and left alignments in the pair originate from different reads (left or right). This might be indirect ligation (mediated by other DNA fragments). + - "R1-2" - unconfirmed pair, right and left alignments in the pair originate from different reads (left or right). This might be indirect ligation (mediated by other DNA fragments). - "R1" - pair originates from the left read. This is direct ligation. - "R2" - pair originated from the right read. Direct ligation. - "R1&2" - pair was sequenced at both left and right read. Direct ligation. diff --git a/pairtools/lib/parse.py b/pairtools/lib/parse.py index c45161e4..2f79a650 100644 --- a/pairtools/lib/parse.py +++ b/pairtools/lib/parse.py @@ -411,7 +411,7 @@ def parse_read( algns2 = [empty_alignment()] algns1[0]["type"] = "X" algns2[0]["type"] = "X" - pair_index = (1, "R1/2") + pair_index = (1, "R1-2") return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments @@ -428,7 +428,7 @@ def parse_read( # By default, assume each molecule is a single pair with single unconfirmed pair: hic_algn1 = algns1[0] hic_algn2 = algns2[0] - pair_index = (1, "R1/2") + pair_index = (1, "R1-2") # Define the type of alignment on each side: is_chimeric_1 = len(algns1) > 1 @@ -539,7 +539,7 @@ def parse2_read( algn1, algn2: dict Two alignments selected for reporting as a Hi-C pair. pair_index - pair index of a pair in the molecule, a tuple: (1, "R1/2") + pair index of a pair in the molecule, a tuple: (1, "R1-2") algns1, algns2: lists All alignments, sorted according to their order in on a read. """ @@ -578,7 +578,7 @@ def parse2_read( algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) - pair_index = (1, "R1/2") + pair_index = (1, "R1-2") return iter([(algns1[0], algn2, pair_index)]), algns1, algns2 # Paired-end mode: @@ -589,7 +589,7 @@ def parse2_read( algns2 = [empty_alignment()] algns1[0]["type"] = "X" algns2[0]["type"] = "X" - pair_index = (1, "R1/2") + pair_index = (1, "R1-2") return iter([(algns1[0], algns2[0], pair_index)]), algns1, algns2 # Generate a sorted, gap-filled list of all alignments @@ -631,7 +631,7 @@ def parse2_read( algn2 = flip_orientation(algn2) if report_position == "walk": algn2 = flip_position(algn2) - pair_index = (1, "R1/2") + pair_index = (1, "R1-2") return iter([(algns1[0], algn2, pair_index)]), algns1, algns2 @@ -948,7 +948,7 @@ def parse_complex_walk( # it's a non-ligated DNA fragment that we don't report. else: # end alignments do not overlap, report regular pair: - pair_index = (len(algns1), "R1/2") + pair_index = (len(algns1), "R1-2") output_pairs.append( format_pair( algns1[-1], @@ -1196,7 +1196,7 @@ def format_pair( if pair_type == "R2": hic_algn1 = flip_orientation(hic_algn1) hic_algn2 = flip_orientation(hic_algn2) - elif pair_type == "R1/2": + elif pair_type == "R1-2": hic_algn2 = flip_orientation(hic_algn2) elif report_orientation == "pair": if pair_type == "R1" or pair_type == "R1&R2": @@ -1218,7 +1218,7 @@ def format_pair( if pair_type == "R2": hic_algn1 = flip_position(hic_algn1) hic_algn2 = flip_position(hic_algn2) - elif pair_type == "R1/2": + elif pair_type == "R1-2": hic_algn2 = flip_position(hic_algn2) elif report_position == "outer": if pair_type == "R1" or pair_type == "R1&R2": diff --git a/tests/data/mock.parse-all.sam b/tests/data/mock.parse-all.sam index 86abdd99..d7ab633f 100644 --- a/tests/data/mock.parse-all.sam +++ b/tests/data/mock.parse-all.sam @@ -1,56 +1,56 @@ @SQ SN:chr1 LN:10000 @SQ SN:chr2 LN:10000 @PG ID:mock PN:mock VN:0.0.0 CL:mock -readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 -readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 -readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 -readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 -readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 -readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 -readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 -readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 -readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 -readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 -readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 -readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 -readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 -readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1-2 +readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1-2 +readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1-2 +readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1-2 +readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1-2 +readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1-2 +readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1-2 +readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1-2 +readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1-2 +readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1-2 +readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1-2 +readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1-2 +readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1-2 +readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1-2 readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 -readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 -readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 -readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1/2 -readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 -readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 -readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1/2 +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1-2 +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1-2 +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|chr1,200,chr1,5324,+,-,UU,2,R1-2 +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1-2 +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1-2 +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,300,+,+,UU,1,R1|chr1,200,chr1,300,+,+,UU,2,R1-2 readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1 -readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 -readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 -readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 -readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1/2|chr1,200,chr1,2024,+,-,UU,3,R2 -readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 -readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 -readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1/2 -readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 -readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 -readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1/2 -readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1/2 +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1-2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1-2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1-2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,10,chr1,324,+,-,UU,1,R1|chr1,300,chr1,2000,+,+,UU,2,R1-2|chr1,200,chr1,2024,+,-,UU,3,R2 +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1-2 +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1-2 +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,NU,2,R1-2 +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1-2 +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1-2 +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,5300,+,+,UU,1,R1|!,0,chr1,5324,-,-,MU,2,R1-2 +readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1-2 diff --git a/tests/data/mock.parse2.sam b/tests/data/mock.parse2.sam index 786c8771..c81a0b30 100644 --- a/tests/data/mock.parse2.sam +++ b/tests/data/mock.parse2.sam @@ -1,56 +1,56 @@ @SQ SN:chr1 LN:10000 @SQ SN:chr2 LN:10000 @PG ID:mock PN:mock VN:0.0.0 CL:mock -readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 -readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1/2 -readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1/2 -readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 -readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1/2 -readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1/2 -readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 -readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1/2 -readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1/2 -readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 -readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1/2 -readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1/2 -readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 -readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1/2 -readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 -readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1/2 -readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 -readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1/2 +readid01 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid01 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid02 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1-2 +readid02 145 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,249,+,-,UU,1,R1-2 +readid03 65 chr1 10 60 1S49M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid03 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,200,+,+,UU,1,R1-2 +readid04 81 chr1 10 60 49M1S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1-2 +readid04 161 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,58,chr1,200,-,+,UU,1,R1-2 +readid05 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid05 145 chr1 200 60 1S49M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid06 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid06 145 chr1 200 60 49M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,248,+,-,UU,1,R1-2 +readid07 97 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1-2 +readid07 145 chr1 200 60 1S48M1S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,10,chr1,247,+,-,UU,1,R1-2 +readid08 105 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid08 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid09 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid09 169 chr1 10 60 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,NU,1,R1-2 +readid10 77 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1-2 +readid10 141 * 0 0 * * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NN,1,R1-2 +readid11 105 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid11 149 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid12 85 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid12 169 chr1 10 0 50M = 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,NM,1,R1-2 +readid13 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1-2 +readid13 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,200,-,+,MU,1,R1-2 +readid14 65 chr1 10 60 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1-2 +readid14 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,chr1,10,-,+,MU,1,R1-2 +readid15 65 chr1 10 0 50M chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1-2 +readid15 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,MM,1,R1-2 readid16 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 readid16 2129 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 readid16 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 -readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 -readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 -readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1/2 -readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 -readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 -readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1/2 +readid17 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1-2 +readid17 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1-2 +readid17 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|chr1,249,chr1,5300,+,-,UU,2,R1-2 +readid18 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1-2 +readid18 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1-2 +readid18 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,249,chr1,324,+,+,UU,2,R1-2 readid19 81 chr1 300 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 readid19 2113 chr1 10 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr10,300,-,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 readid19 129 chr1 200 60 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,324,+,+,UU,1,R1 -readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 -readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 -readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 -readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1/2|chr1,224,chr1,2000,+,-,UU,3,R2 -readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 -readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 -readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1/2 -readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 -readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 -readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1/2 -readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1/2 +readid20 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,300,+,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1-2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 2113 chr1 300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1-2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 129 chr1 200 60 25M25S chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1-2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid20 2177 chr1 2000 60 25S25M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,2000,+,25S25M,60,0; CT:Z:SIMULATED:chr1,34,chr1,300,+,-,UU,1,R1|chr1,324,chr1,2024,+,+,UU,2,R1-2|chr1,224,chr1,2000,+,-,UU,3,R2 +readid21 105 chr1 10 60 25M25S * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1-2 +readid21 2169 chr1 5300 60 25M25H * 0 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1-2 +readid21 141 * 0 0 * chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,NU,2,R1-2 +readid22 65 chr1 10 60 25M25S chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,5300,-,25M25H,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,+,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1-2 +readid22 2129 chr1 5300 60 25M25H chr1 200 0 AAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 SA:Z:chr1,10,+,25M25S,60,0; CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1-2 +readid22 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:chr1,34,chr1,5324,+,-,UU,1,R1|!,0,chr1,5300,-,-,MU,2,R1-2 +readid23 129 chr1 200 0 50M chr1 10 0 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA NM:i:0 NM:i:0 CT:Z:SIMULATED:!,0,!,0,-,-,XX,1,R1-2 From f4ac2d8c5f086c5c461e96416f6656b1cb44f8ee Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 3 May 2022 17:40:14 -0400 Subject: [PATCH 40/52] Benchmarks added --- examples/benchmark/Snakefile | 178 ++++++ examples/benchmark/benchmark.ipynb | 978 +++++++++++++++++++++++++++++ 2 files changed, 1156 insertions(+) create mode 100644 examples/benchmark/Snakefile create mode 100644 examples/benchmark/benchmark.ipynb diff --git a/examples/benchmark/Snakefile b/examples/benchmark/Snakefile new file mode 100644 index 00000000..0d3d0366 --- /dev/null +++ b/examples/benchmark/Snakefile @@ -0,0 +1,178 @@ +cores_choices = [1, 2, 4] +memory_choices = ["low", "high"] +pairtools_versions = ["pairtools03", "pairtools1", "pairtools1_bwamem2"] + +chromap = expand( + "output/result.chromap.chromap.{memory}.{cores}.pairs", + cores=cores_choices, + memory=memory_choices, +) +juicer = expand( + "output/result.juicer.juicer.{memory}.{cores}.pairs", + cores=cores_choices, + memory=["regular"], +) +hicexplorer = expand( + "output/result.hicexplorer.hicexplorer.{memory}.{cores}.cool", + cores=cores_choices, + memory=memory_choices, +) +fanc_bwa = expand( + "output/result.fanc_bwa.fanc_bwa.{memory}.{cores}.pairs", + cores=cores_choices, + memory=["regular"], +) +fanc_bowtie = expand( + "output/result.fanc_bowtie2.fanc_bowtie2.{memory}.{cores}.pairs", + cores=cores_choices, + memory=["regular"], +) +hicpro = expand( + "output/result.hicpro.hicpro.{memory}.{cores}.pairs", + cores=cores_choices, + memory=["regular"], +) +pairtools_cython = expand( + "output/result.{mode}.{regime}.{memory}.{cores}.pairs", + regime=['cython'], + mode=pairtools_versions, + cores=cores_choices, + memory=["regular"], +) +pairtools_nocython = expand( + "output/result.{mode}.{regime}.{memory}.{cores}.pairs", + regime=['sklearn', 'scipy'], + mode=pairtools_versions, + cores=cores_choices, + memory=memory_choices, +) + +rule all: + input: + lambda wildcards: hicexplorer #fanc_bowtie + fanc_bwa + pairtools_cython + pairtools_nocython + chromap + hicpro +# hicpro + +# + juicer # run separately with the number of cores equal to tested! + +rule test: + input: + fastq1="data/SRR6107789_1.fastq.gz", + fastq2="data/SRR6107789_2.fastq.gz", + genomefile="data/hg38/hg38.fa", + chromsizes="data/hg38/hg38.fa.sizes", + genome_index_bwa="data/hg38/index/bwa/hg38.fa", + genome_index_chromap="data/hg38/index/chromap/hg38", + genome_index_bwamem2="data/hg38/index/bwa-mem2/hg38", + genome_index_bowtie2="data/hg38/index/bowtie2/hg38", + genome_rsites="data/hg38/hg38.DpnII.bed", + threads: lambda wildcards: int(wildcards.cores), + output: + file="output/result.{mode}.{regime}.{memory}.{cores}.{format}", + benchmark: + repeat( + "benchmarks/result.{mode}.{regime}.{memory}.{cores}.{format}.benchmark", + 5, + ) + params: + memory_chromap = lambda wildcards: '--low-mem' if (wildcards.memory=='low') else '', # for chromap only + chunksize_pairtools = lambda wildcards: '--chunksize 100000' if (wildcards.memory=='low') else '--chunksize 10000000', # for pairtools 1.0.0 and above + memory_hicpro = lambda wildcards: "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 100M/' $TMP_CONFIG" if (wildcards.memory=='low') else "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 10000M/' $TMP_CONFIG", + chunksize_hicexplorer = lambda wildcards: '--inputBufferSize 100000' if (wildcards.memory == 'low') else '--inputBufferSize 10000000' # for pairtools 1.0.0 and above + run: + if wildcards.mode == "pairtools03": + shell(""" + soft/pairtools0.3.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ + soft/pairtools0.3.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ + soft/pairtools0.3.0/bin/pairtools sort --nproc {wildcards.cores} | \ + soft/pairtools0.3.0/bin/pairtools dedup -o {output.file} + """) + elif wildcards.mode == "pairtools1_bwamem2": + shell(""" + soft/bwa-mem2/bwa-mem2 mem -t {wildcards.cores} -SP {input.genome_index_bwamem2} {input.fastq1} {input.fastq2} | \ + soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ + soft/pairtools1.0.0/bin/pairtools sort --nproc {wildcards.cores} | \ + soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --backend {wildcards.regime} {params.chunksize_pairtools} \ + -o {output.file} + """) + elif wildcards.mode == "pairtools1": + shell(""" + soft/pairtools1.0.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ + soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ + soft/pairtools1.0.0/bin/pairtools sort --nproc {wildcards.cores} | \ + soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --backend {wildcards.regime} {params.chunksize_pairtools} \ + -o {output.file} + """) + + elif wildcards.mode == "chromap": + shell(""" + soft/chromap/bin/chromap --preset hic {params.memory_chromap}\ + -t {wildcards.cores} -x {input.genome_index_chromap} -r {input.genomefile} \ + -1 {input.fastq1} -2 {input.fastq2} -o {output.file} + """) + elif wildcards.mode == "fanc_bwa": + shell(""" + TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) + TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bwa} $TMP_FILE1 + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bwa} $TMP_FILE2 + samtools sort -@ {wildcards.cores} -n $TMP_FILE1 -o $TMP_FILE1.sorted + samtools sort -@ {wildcards.cores} -n $TMP_FILE2 -o $TMP_FILE2.sorted + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted $TMP_FILE2.sorted {output.file} + rm $TMP_FILE1 $TMP_FILE1.sorted $TMP_FILE2 $TMP_FILE2.sorted + """) + elif wildcards.mode == "fanc_bowtie2": + shell(""" + TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) + TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bowtie2} $TMP_FILE1 + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bowtie2} $TMP_FILE2 + samtools sort -@ {wildcards.cores} -n $TMP_FILE1 -o $TMP_FILE1.sorted + samtools sort -@ {wildcards.cores} -n $TMP_FILE2 -o $TMP_FILE2.sorted + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted $TMP_FILE2.sorted {output.file} + rm $TMP_FILE1 $TMP_FILE1.sorted $TMP_FILE2 $TMP_FILE2.sorted + """) + elif wildcards.mode == "hicpro": + shell(""" + cd soft/HiC-Pro_env/HiC-Pro/ + TMP_CONFIG=$(mktemp output/tmp.XXXXXXXX) + TMP_DIR=$(mktemp -d output/tmp.XXXXXXXX) + cp config-hicpro.txt $TMP_CONFIG + + sed -i 's/N_CPU = 4/N_CPU = {wildcards.cores}/' $TMP_CONFIG + {params.memory_hicpro} + bin/HiC-Pro -i rawdata/ -o $TMP_DIR -c $TMP_CONFIG + + # Cleanup: + cp $TMP_DIR/hic_results/data/sample1/sample1.allValidPairs {output.file} + rm -r $TMP_DIR $TMP_CONFIG + """) + elif wildcards.mode == "juicer": + # Note that this process is not guaranteed to work well in parallel mode; + # recommended to run separately + shell(""" + soft/juicer-1.6/CPU/juicer.sh -g hg38 -d data/4juicer/ -s DpnII -S early \ + -p {input.chromsizes} -y {input.genome_rsites} -z {input.genome_index_bwa} -t {wildcards.cores} -D soft/juicer-1.6/CPU + + # Cleanup: + mv data/4juicer/aligned/merged_nodups.txt {output.file} + rm -rf data/4juicer/aligned data/4juicer/splits/*[^q] + """) + elif wildcards.mode == "hicexplorer": + # Note that this process is not guaranteed to work well in parallel mode; + # recommended to run separately + shell(""" + TMP_DIR=$(mktemp -d output/tmp.XXXXXXXX) + + soft/hicexplorer/bin/hicBuildMatrix --samFiles \ + <(bwa mem -A1 -B4 -E50 -L0 {input.genome_index_bwa} -t {wildcards.cores} data/SRR6107789_1.fastq.gz | samtools view -@ {wildcards.cores} -Shb -) \ + <(bwa mem -A1 -B4 -E50 -L0 {input.genome_index_bwa} -t {wildcards.cores} data/SRR6107789_2.fastq.gz | samtools view -@ {wildcards.cores} -Shb -) \ + --restrictionSequence GATC \ + --danglingSequence GATC \ + --restrictionCutFile {input.genome_rsites} \ + --threads {wildcards.cores} \ + {params.chunksize_hicexplorer} \ + --QCfolder $TMP_DIR \ + -o {output.file} + + # Cleanup: + rm -r $TMP_DIR + """) diff --git a/examples/benchmark/benchmark.ipynb b/examples/benchmark/benchmark.ipynb new file mode 100644 index 00000000..37859570 --- /dev/null +++ b/examples/benchmark/benchmark.ipynb @@ -0,0 +1,978 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "864d317a-4960-4315-846d-ba2f36014614", + "metadata": {}, + "source": [ + "# Pairtools benchmarking\n", + "\n", + "Welcome to pairtools benchmarking.\n", + "\n", + "We will test performance of different software for mapping Hi-C and Hi-C-like methods:\n", + "\n", + "- bwa mem and pairtools\n", + "\n", + "- bwa-mem2 and pairtools\n", + "\n", + "- chromap\n", + "\n", + "- HiC-Pro\n", + "\n", + "- Juicer\n", + "\n", + "- FAN-C\n", + "\n", + "- HiCExplorer\n", + "\n", + "\n", + "The outline:\n", + "\n", + "1. [Install software](#Install-software)\n", + "\n", + "2. [Download data and genome](#Download-data-and-genome)\n", + "\n", + "3. [Run](#Run)\n", + "\n", + "4. [Visualize benchmarks](#Visualize-benchmarks)" + ] + }, + { + "cell_type": "markdown", + "id": "8ae7b1ea-f64b-4740-8694-2fdb1d7353c4", + "metadata": {}, + "source": [ + "## Install software\n", + "\n", + "We will use separate conda environments to install different utilities. Each utility will have its own environment and peth to the binaries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f98ab45-3759-4260-ab9f-79e487410d5f", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "mkdir ./soft" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5128b353-cb8a-4d67-b6af-a9d7f730bbdf", + "metadata": {}, + "outputs": [], + "source": [ + "# Consider adding: https://hicexplorer.readthedocs.io/en/latest/content/tools/hicBuildMatrix.html#hicbuildmatrix\n", + "### HiCExplorer\n", + "\n", + "# conda install hicexplorer -c bioconda -c conda-forge\n", + "\n", + "# hicBuildMatrix" + ] + }, + { + "cell_type": "markdown", + "id": "b9dc2f27-868f-4bfd-bd9f-d88d18d6655f", + "metadata": {}, + "source": [ + "### pairtools" + ] + }, + { + "cell_type": "markdown", + "id": "a9d26560-7035-44c5-bf8c-f4f9d4c63794", + "metadata": {}, + "source": [ + "#### pairtools v 0.3.0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0e2ac73-18c4-445f-a3f5-142f79d67ae0", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "conda create -y --prefix soft/pairtools0.3.0 python=3.9 pip\n", + "conda activate soft/pairtools0.3.0\n", + "conda install -y -c conda-forge -c bioconda \"pairtools=0.3.0\"\n", + "conda install -y -c bioconda \"bwa>=0.7.17\"" + ] + }, + { + "cell_type": "markdown", + "id": "cd56a6ab-3836-445c-ab70-73eaa4e80da8", + "metadata": {}, + "source": [ + "#### pairtools v 1.0.0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3e0038a-f034-4c40-8e5d-d50f2351679f", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "conda create -y --prefix soft/pairtools1.0.0 python=3.9 pip\n", + "conda activate soft/pairtools1.0.0\n", + "pip install cython\n", + "pip install git+https://github.com/open2c/pairtools.git@pre0.4.0 \n", + "conda install -y -c bioconda \"bwa>=0.7.17\"" + ] + }, + { + "cell_type": "markdown", + "id": "a7548c59-7cd2-40f8-85da-7a6b2ede143d", + "metadata": {}, + "source": [ + "#### Install bwa-mem2\n", + "[bwa-mem2](https://github.com/bwa-mem2/bwa-mem2) has significantly improved performance while having the same results. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "695cdebb-7a4b-4ca9-b2a5-f0a178874b77", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "conda activate soft/pairtools1.0.0\n", + "\n", + "# bwa-mem2: compile from source (not recommended for general users)\n", + "\n", + "# Get the source\n", + "git clone --recursive https://github.com/bwa-mem2/bwa-mem2 soft/bwa-mem2\n", + "cd soft/bwa-mem2\n", + "\n", + "# Compile\n", + "make\n", + "\n", + "# Exit compilation folder\n", + "cd ../../" + ] + }, + { + "cell_type": "markdown", + "id": "0bc9befa-e4cc-4cf3-84d5-fbae94a2e6fb", + "metadata": {}, + "source": [ + "### chromap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f02a8e1-998e-4383-bc8a-d9d493b425ef", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "conda create -y --prefix soft/chromap\n", + "conda activate soft/chromap\n", + "conda install -y -c bioconda -c conda-forge chromap" + ] + }, + { + "cell_type": "markdown", + "id": "37f50ca4-74a2-44a3-8038-83a4d7b43c85", + "metadata": {}, + "source": [ + "### HiC-Pro\n", + "\n", + "[HiC-Pro](https://github.com/nservant/HiC-Pro) is a popular software for Hi-C mapping, its now part of nf-core Hi-C pipeline, supports both fragment-based analysis of Hi-C and fragement-free analysis of DNase-based Hi-C." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45c9697c-5f49-4a53-bbf0-18535f05e465", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "git clone https://github.com/nservant/HiC-Pro.git soft/HiC-Pro_env/HiC-Pro\n", + "conda env create -f soft/HiC-Pro/environment.yml -p soft/HiC-Pro_env\n", + "### Working environment will be soft/HiC-Pro_env\n", + "\n", + "conda activate soft/HiC-Pro_env\n", + "\n", + "# Install dependencies\n", + "conda install -y -c bioconda bowtie2 samtools pysam numpy scipy bx-python\n", + "conda install -y -c r r r-rcolorbrewer r-ggplot2\n", + "\n", + "# Copy prepared config:\n", + "cp configs/config-hicpro_install.txt soft/HiC-Pro_env/HiC-Pro/config-install.txt\n", + "\n", + "# Configure and install:\n", + "cd soft/HiC-Pro_env/HiC-Pro\n", + "make configure\n", + "make install\n", + "\n", + "cd ../../../\n", + "\n", + "# Retain only data processing steps with no creating of maps:\n", + "sed -i \"s/all : init mapping proc_hic merge_persample hic_qc build_raw_maps ice_norm/all : init mapping proc_hic merge_persample #hic_qc build_raw_maps ice_norm/\" soft/HiC-Pro_env/HiC-Pro/scripts/Makefile" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18e29459-334a-458f-8244-ede873b25258", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Note that the configs should be adjusted for your system:\n", + "cp configs/config-hicpro_install.txt soft/HiC-Pro_env/HiC-Pro/config-install.txt\n", + "cp configs/config-hicpro.txt soft/HiC-Pro_env/HiC-Pro/config-hicpro.txt" + ] + }, + { + "cell_type": "markdown", + "id": "d00d4aed-94b4-4de6-83b2-9950c9d7b949", + "metadata": {}, + "source": [ + "### FAN-C" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ebd9a60-f0d0-4f0b-9a64-d2ea386a15f9", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "conda create -y --prefix soft/fanc python=3.9 pip hdf5\n", + "conda activate soft/fanc\n", + "pip install fanc\n", + "conda install -y -c bioconda samtools" + ] + }, + { + "cell_type": "markdown", + "id": "a2b58a8e-b828-47c7-87f2-86337657f5e4", + "metadata": {}, + "source": [ + "### Juicer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2611844-0e32-465f-befa-a8e296bf54d2", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "\n", + "conda create -y --prefix soft/juicer\n", + "conda activate soft/juicer\n", + "\n", + "conda install -y -c bioconda bwa java-jdk\n", + "conda install -y -c conda-forge coreutils\n", + "\n", + "# Download the recommended stable version:\n", + "wget https://github.com/aidenlab/juicer/archive/refs/tags/1.6.zip\n", + "unzip 1.6.zip\n", + "rm 1.6.zip\n", + "mv juicer-1.6 soft/juicer-1.6\n", + "\n", + "# Download compile jar files of the stable version:\n", + "wget http://hicfiles.tc4ga.com.s3.amazonaws.com/public/juicer/juicer_tools.1.6.2_jcuda.0.7.5.jar\n", + "mv juicer_tools.1.6.2_jcuda.0.7.5.jar soft/juicer-1.6/CPU/scripts/common/juicer_tools.jar\n", + "\n", + "# Copy the scripts to some accessible location:\n", + "mkdir -p soft/juicer-1.6/CPU/scripts/\n", + "cp -r soft/juicer-1.6/CPU/[^s]* soft/juicer-1.6/CPU/scripts/" + ] + }, + { + "cell_type": "markdown", + "id": "3e02b40b-1f5c-4bf8-89fc-36af2f485c55", + "metadata": {}, + "source": [ + "### HiCExplorer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d5e4ffd-7908-44eb-9d22-22cb24170207", + "metadata": {}, + "outputs": [], + "source": [ + "conda create -y --prefix soft/hicexplorer python=3.9\n", + "conda activate soft/hicexplorer\n", + "conda install -y -c bioconda hicexplorer bwa" + ] + }, + { + "cell_type": "markdown", + "id": "e325db7c-93d8-4e48-9ba6-8867956398cd", + "metadata": {}, + "source": [ + "## Download data and genome" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "aaea1786-7c9b-425c-9aac-de8ac709688c", + "metadata": {}, + "outputs": [], + "source": [ + "mkdir data" + ] + }, + { + "cell_type": "markdown", + "id": "d4372383-a702-44f5-89e7-66746700f765", + "metadata": {}, + "source": [ + "### Download raw data\n", + "\n", + "Test data from Rao et al. 2017, 1 mln pairs: " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "05b7140b-454d-4bd2-842f-a0d042701a4e", + "metadata": {}, + "outputs": [], + "source": [ + "fastq-dump -O data --gzip --split-files SRR6107789 --minSpotId 0 --maxSpotId 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2d2952e1-528a-41dc-8efc-be866e958c89", + "metadata": {}, + "outputs": [], + "source": [ + "# Put the data in accessible folder for juicer: \n", + "mkdir -p data/4juicer/fastq/\n", + "mkdir -p data/4juicer/splits/\n", + "cp data/SRR6107789_1.fastq.gz data/4juicer/fastq/SRR6107789_R1.fastq.gz\n", + "cp data/SRR6107789_2.fastq.gz data/4juicer/fastq/SRR6107789_R2.fastq.gz\n", + "cp data/4juicer/fastq/* data/4juicer/splits/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "083d9534-ce41-45b1-98f4-2007c64fb5f3", + "metadata": {}, + "outputs": [], + "source": [ + "# Put the data in accessible folder for HiC-Pro:\n", + "mkdir -p soft/HiC-Pro_env/HiC-Pro/rawdata/sample1\n", + "cp data/S*fastq.gz soft/HiC-Pro_env/HiC-Pro/rawdata/sample1/" + ] + }, + { + "cell_type": "markdown", + "id": "a4683297-4109-4786-8faa-26089fa8d3e4", + "metadata": {}, + "source": [ + "### Install genome" + ] + }, + { + "cell_type": "markdown", + "id": "1c29a2d6-cdf4-4552-b856-9316b8e332d4", + "metadata": {}, + "source": [ + "#### Genomepy installation\n", + "will install fasta, bwa and bowtie2 indexes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3bf9ab65-da9c-41f0-adc6-f7f9d268e55e", + "metadata": {}, + "outputs": [], + "source": [ + "# Activate bwa plugin for genomepy:\n", + "! genomepy plugin enable bwa bowtie2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b7dc978-408d-4b32-8a32-119645b24c9f", + "metadata": {}, + "outputs": [], + "source": [ + "# Install hg38 genome by genomepy:\n", + "! genomepy install hg38 -g data/" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3fe79dca-fc66-4b81-904f-bfedc7cfd5b1", + "metadata": {}, + "outputs": [], + "source": [ + "# Restrict the genome:\n", + "! cooler digest data/hg38/hg38.fa.sizes data/hg38/hg38.fa DpnII -o data/hg38/hg38.DpnII.bed" + ] + }, + { + "cell_type": "markdown", + "id": "8db4bf50-7e32-4b01-bb2c-a2f1c02565f7", + "metadata": { + "tags": [] + }, + "source": [ + "#### Build genome index: bwa-mem2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2691bce-a469-495c-aa3e-2abb6105b1f4", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "mkdir data/hg38/index/bwa-mem2/\n", + "soft/bwa-mem2/bwa-mem2 index -p data/hg38/index/bwa-mem2/hg38 data/hg38/hg38.fa" + ] + }, + { + "cell_type": "markdown", + "id": "3274559c-b130-4d40-93f1-59efc3abb1ed", + "metadata": { + "tags": [] + }, + "source": [ + "#### Build genome index: chromap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "993b7093-d896-4726-bfd5-77c86bb5d302", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash \n", + "mkdir data/hg38/index/chromap\n", + "chromap -i -r data/hg38/hg38.fa -o data/hg38/index/chromap/hg38" + ] + }, + { + "cell_type": "markdown", + "id": "5a9bd0a9-9dc0-4942-bb1b-cf7b77363bb6", + "metadata": {}, + "source": [ + "## Run\n", + "\n", + "The banchmarking is usually cumbersome, but it can be simplified by snakemake. We provide a Snakemake pipeline that will allow you to benchmark different approaches.\n", + "\n", + "The output of snakemake will consist of resulting Hi-C pairs/maps in `output` folder and benchmarking files in `benchmarks` folder. \n", + "The file names have the information on parameters in their names:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad48c488-05f4-4b2d-a18d-2b399e8b03b0", + "metadata": {}, + "outputs": [], + "source": [ + "# Running \n", + "snakemake --cores 10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b086bae-ef42-41bb-9254-42af10c9ab1b", + "metadata": {}, + "outputs": [], + "source": [ + "# Cleanup\n", + "rm output/*; rm benchmarks/*" + ] + }, + { + "cell_type": "markdown", + "id": "e46dffea-87ac-4157-8938-ae032d50a591", + "metadata": {}, + "source": [ + "## Manual run\n", + "\n", + "You may also run them to test individual steps of the pipeline." + ] + }, + { + "cell_type": "markdown", + "id": "6dcbff7b-8caf-4512-9c44-375eac698730", + "metadata": {}, + "source": [ + "### pairtools" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7da2496b-fd21-4383-a3df-ba9fadb9e505", + "metadata": {}, + "outputs": [], + "source": [ + "soft/bwa-mem2/bwa-mem2 mem -t 5 -SP data/hg38/index/bwa-mem2/hg38 data/SRR6107789_1.fastq.gz data/SRR6107789_2.fastq.gz | \\\n", + " soft/pairtools1.0.0/bin/pairtools parse --nproc-in 5 --nproc-out 5 --drop-sam --drop-seq -c data/hg38/hg38.fa.sizes | \\\n", + " soft/pairtools1.0.0/bin/pairtools sort --nproc 5 | \\\n", + " soft/pairtools1.0.0/bin/pairtools dedup -p 5 --backend cython \\\n", + " -o output/result.pairtools.pairs" + ] + }, + { + "cell_type": "markdown", + "id": "b0c9a7e3-8e08-42bf-9748-cd94eff6731a", + "metadata": {}, + "source": [ + "### chromap" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3012cdb-be1c-46ef-bb7a-20eff2d34fba", + "metadata": {}, + "outputs": [], + "source": [ + "soft/chromap/bin/chromap --preset hic --low-mem \\\n", + " -t 5 -x data/hg38/index/chromap/hg38 -r data/hg38/hg38.fa \\\n", + " -1 data/SRR6107789_1.fastq.gz -2 data/SRR6107789_2.fastq.gz -o output/result.chromap.pairs" + ] + }, + { + "cell_type": "markdown", + "id": "32e60c83-1fab-4fcb-ba0b-8c1258e457c6", + "metadata": {}, + "source": [ + "### HiC-Pro" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5931f3a6-82f1-4fd8-b65c-9ed648b5f986", + "metadata": {}, + "outputs": [], + "source": [ + "cd soft/HiC-Pro_env/HiC-Pro\n", + "bin/HiC-Pro -i rawdata/ -o output -c config-hicpro.txt\n", + "\n", + "cd ../../../" + ] + }, + { + "cell_type": "markdown", + "id": "43171a68-8928-418c-9779-268a5d4923d3", + "metadata": {}, + "source": [ + "### FAN-C\n", + "Based on [CLI tutorial](https://fan-c.readthedocs.io/en/latest/fanc-executable/fanc-generate-hic/fanc_modular_steps.html):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "802e66a8-4c93-45d6-a735-4a68a1d9184a", + "metadata": {}, + "outputs": [], + "source": [ + "fanc map -t 5 data/SRR6107789_1.fastq.gz data/hg38/index/bwa/hg38.fa output/fanc-output_1.bam\n", + "fanc map -t 5 data/SRR6107789_2.fastq.gz data/hg38/index/bwa/hg38.fa output/fanc-output_2.bam\n", + "samtools sort -@ 5 -n output/fanc-output_1.bam -o output/fanc-output_1.sorted.bam\n", + "samtools sort -@ 5 -n output/fanc-output_2.bam -o output/fanc-output_2.sorted.bam\n", + "fanc pairs output/fanc-output_1.sorted.bam output/fanc-output_2.sorted.bam output/fanc-output.pairs -g data/hg38/hg38.DpnII.bed" + ] + }, + { + "cell_type": "markdown", + "id": "46f11121-bff6-4f92-8d80-aa86b01ffcc0", + "metadata": {}, + "source": [ + "### Juicer" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1a5571c-b1da-4125-b915-34884be7299e", + "metadata": {}, + "outputs": [], + "source": [ + "soft/juicer-1.6/CPU/juicer.sh -g hg38 -d data/4juicer/ -s DpnII -S early -p data/hg38/hg38.fa.sizes -y data/hg38/hg38.DpnII.bed -z data/hg38/index/bwa/hg38.fa -t 5 -D soft/juicer-1.6/CPU" + ] + }, + { + "cell_type": "markdown", + "id": "871ac7b7-0180-4103-a8b3-bd49b7269d83", + "metadata": {}, + "source": [ + "### HiCExplorer\n", + "Based on the example: https://hicexplorer.readthedocs.io/en/latest/content/example_usage.html" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f14967d-ed63-4d20-a006-bc038d1f1f6f", + "metadata": {}, + "outputs": [], + "source": [ + "hicBuildMatrix --samFiles \\\n", + " <(bwa mem -t 4 -A1 -B4 -E50 -L0 data/hg38/index/bwa/hg38.fa data/SRR6107789_1.fastq.gz | samtools view -Shb -) \\\n", + " <(bwa mem -t 4 -A1 -B4 -E50 -L0 data/hg38/index/bwa/hg38.fa data/SRR6107789_2.fastq.gz | samtools view -Shb -) \\\n", + " --restrictionSequence GATC \\\n", + " --danglingSequence GATC \\\n", + " --restrictionCutFile data/hg38/hg38.DpnII.bed \\\n", + " --threads 4 \\\n", + " --inputBufferSize 100000 \\\n", + " --QCfolder hicexplorer_tmp \\\n", + " -o hicexplorer_output.cool" + ] + }, + { + "cell_type": "markdown", + "id": "9b3b93e5-47b1-408f-a4d5-32a85060fd8a", + "metadata": {}, + "source": [ + "## Visualize benchmarks" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5a59f6bc-be2d-442b-b4ac-07237f38c38b", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bbf69dd7-919d-4f41-82ea-ff7138c6c62e", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1674f09e-e258-4752-a029-2b109321f9d9", + "metadata": {}, + "outputs": [], + "source": [ + "import glob" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dd9e829a-f25e-4c66-b22d-01e008143396", + "metadata": {}, + "outputs": [], + "source": [ + "files = glob.glob(\"benchmarks/*\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "08707677-e087-44ca-8e8a-9d74ef4482a4", + "metadata": {}, + "outputs": [], + "source": [ + "def get_params(filename):\n", + " split = filename.split('.')\n", + " util= split[1]\n", + " regime = split[2]\n", + " memory = split[3]\n", + " ncores = int(split[4])\n", + " \n", + " return util, regime, memory, ncores\n", + "\n", + "timings = []\n", + "for f in files:\n", + " t = pd.read_table(f)\n", + " t[['util', 'regime', 'memory', 'ncores']] = get_params(f)\n", + " timings.append(t)\n", + "timings = pd.concat(timings)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d43f8549-4765-441c-b94c-eb76a950ca4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sh:m:smax_rssmax_vmsmax_ussmax_pssio_inio_outmean_loadcpu_timeutilregimememoryncores
02232.28650:37:125496.668171.815424.345429.7712137.590.0271.361593.63pairtools03sklearnlow1
11600.84230:26:405449.218171.815443.505444.0319172.3939.2583.871356.28pairtools03sklearnlow1
21439.15960:23:595446.208171.815444.195444.8727448.7384.0084.3543.03pairtools03sklearnlow1
31045.36550:17:255574.158171.815512.735517.6427467.57117.71101.111095.38pairtools03sklearnlow1
41031.91710:17:115574.228171.815512.795517.9327467.58156.94102.401106.47pairtools03sklearnlow1
\n", + "
" + ], + "text/plain": [ + " s h:m:s max_rss max_vms max_uss max_pss io_in io_out \\\n", + "0 2232.2865 0:37:12 5496.66 8171.81 5424.34 5429.77 12137.59 0.02 \n", + "1 1600.8423 0:26:40 5449.21 8171.81 5443.50 5444.03 19172.39 39.25 \n", + "2 1439.1596 0:23:59 5446.20 8171.81 5444.19 5444.87 27448.73 84.00 \n", + "3 1045.3655 0:17:25 5574.15 8171.81 5512.73 5517.64 27467.57 117.71 \n", + "4 1031.9171 0:17:11 5574.22 8171.81 5512.79 5517.93 27467.58 156.94 \n", + "\n", + " mean_load cpu_time util regime memory ncores \n", + "0 71.36 1593.63 pairtools03 sklearn low 1 \n", + "1 83.87 1356.28 pairtools03 sklearn low 1 \n", + "2 84.35 43.03 pairtools03 sklearn low 1 \n", + "3 101.11 1095.38 pairtools03 sklearn low 1 \n", + "4 102.40 1106.47 pairtools03 sklearn low 1 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timings.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ba0c1c4f-ac4c-43f5-8245-e32d1d4cc3cf", + "metadata": {}, + "outputs": [], + "source": [ + "df = timings.sort_values(['ncores', 'util', 'regime', 'memory'])\n", + "df.loc[:, \"method\"] = df.apply(lambda x: f'{x.util}.{x.regime}', axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "8f31f3be-cf8f-4976-9a60-28e97c13593d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[10,10])\n", + "ax = sns.barplot(x=\"s\", y=\"method\", data=df.query('ncores==2'), orient='h')\n", + "plt.xscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "ef137624-1bad-440e-bfaf-462dc42802bb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=[10,10])\n", + "ax = sns.barplot(x=\"max_rss\", y=\"method\", data=df.query('ncores==2'), orient='h')\n", + "plt.xscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66a8ddab-050d-4949-bad3-e3ccdf6277d8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "test", + "language": "python", + "name": "test" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From da087bb560d49b933791dee61a8cb4dc66ff72f3 Mon Sep 17 00:00:00 2001 From: Phlya Date: Wed, 4 May 2022 16:20:02 +0200 Subject: [PATCH 41/52] Extract tile info much faster (pd.str.split sucks) --- pairtools/lib/stats.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index dac60066..7ca266a0 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -809,7 +809,8 @@ def extract_tile_info(series, regex=False): raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") return split[0] + ":" + split[1] + ":" + split[2] else: - split = series.str.split(":", expand=True) - if split.shape[1]<5: + try: + split = [":".join(name.split(':')[2:5]) for name in series] + except: raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") - return split[2] + ":" + split[3] + ":" + split[4] + return split From 24f7a1971d40f5ac72639ba0e006c247a0a333c6 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Wed, 4 May 2022 15:16:55 -0400 Subject: [PATCH 42/52] snakefile and restriction walkthrough update. --- examples/benchmark/Snakefile | 87 ++- examples/pairtools_restrict_walkthrough.ipynb | 709 ++++++++++++++++++ 2 files changed, 756 insertions(+), 40 deletions(-) create mode 100644 examples/pairtools_restrict_walkthrough.ipynb diff --git a/examples/benchmark/Snakefile b/examples/benchmark/Snakefile index 0d3d0366..1c6437c7 100644 --- a/examples/benchmark/Snakefile +++ b/examples/benchmark/Snakefile @@ -1,55 +1,66 @@ cores_choices = [1, 2, 4] memory_choices = ["low", "high"] -pairtools_versions = ["pairtools03", "pairtools1", "pairtools1_bwamem2"] +# pairtools_versions = ["pairtools03", "pairtools1", "pairtools1_bwamem2"] chromap = expand( - "output/result.chromap.chromap.{memory}.{cores}.pairs", + "output/result.chromap.{memory}.{cores}.pairs", cores=cores_choices, memory=memory_choices, ) juicer = expand( - "output/result.juicer.juicer.{memory}.{cores}.pairs", + "output/result.juicer.{memory}.{cores}.pairs", cores=cores_choices, memory=["regular"], ) hicexplorer = expand( - "output/result.hicexplorer.hicexplorer.{memory}.{cores}.cool", + "output/result.hicexplorer.{memory}.{cores}.cool", cores=cores_choices, memory=memory_choices, ) fanc_bwa = expand( - "output/result.fanc_bwa.fanc_bwa.{memory}.{cores}.pairs", + "output/result.fanc_bwa.{memory}.{cores}.pairs", cores=cores_choices, memory=["regular"], ) fanc_bowtie = expand( - "output/result.fanc_bowtie2.fanc_bowtie2.{memory}.{cores}.pairs", + "output/result.fanc_bowtie2.{memory}.{cores}.pairs", cores=cores_choices, memory=["regular"], ) hicpro = expand( - "output/result.hicpro.hicpro.{memory}.{cores}.pairs", + "output/result.hicpro.{memory}.{cores}.pairs", cores=cores_choices, memory=["regular"], ) -pairtools_cython = expand( - "output/result.{mode}.{regime}.{memory}.{cores}.pairs", - regime=['cython'], - mode=pairtools_versions, +pairtools = expand( + "output/result.pairtools.{memory}.{cores}.pairs", cores=cores_choices, - memory=["regular"], + memory=memory_choices, ) -pairtools_nocython = expand( - "output/result.{mode}.{regime}.{memory}.{cores}.pairs", - regime=['sklearn', 'scipy'], - mode=pairtools_versions, +pairtools_bwamem2 = expand( + "output/result.pairtools_bwamem2.{memory}.{cores}.pairs", cores=cores_choices, memory=memory_choices, ) +# pairtools_cython = expand( +# "output/result.{mode}.{regime}.{memory}.{cores}.pairs", +# regime=['cython'], +# mode=pairtools_versions, +# cores=cores_choices, +# memory=["regular"], +# ) +# pairtools_nocython = expand( +# "output/result.{mode}.{regime}.{memory}.{cores}.pairs", +# regime=['sklearn', 'scipy'], +# mode=pairtools_versions, +# cores=cores_choices, +# memory=memory_choices, +# ) rule all: input: - lambda wildcards: hicexplorer #fanc_bowtie + fanc_bwa + pairtools_cython + pairtools_nocython + chromap + hicpro + lambda wildcards: hicexplorer + hicpro +# fanc_bowtie + fanc_bwa + pairtools_cython + pairtools_nocython + chromap # hicpro + # + juicer # run separately with the number of cores equal to tested! @@ -66,10 +77,10 @@ rule test: genome_rsites="data/hg38/hg38.DpnII.bed", threads: lambda wildcards: int(wildcards.cores), output: - file="output/result.{mode}.{regime}.{memory}.{cores}.{format}", + file="output/result.{mode}.{memory}.{cores}.{format}", benchmark: repeat( - "benchmarks/result.{mode}.{regime}.{memory}.{cores}.{format}.benchmark", + "benchmarks/result.{mode}.{memory}.{cores}.{format}.benchmark", 5, ) params: @@ -78,14 +89,14 @@ rule test: memory_hicpro = lambda wildcards: "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 100M/' $TMP_CONFIG" if (wildcards.memory=='low') else "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 10000M/' $TMP_CONFIG", chunksize_hicexplorer = lambda wildcards: '--inputBufferSize 100000' if (wildcards.memory == 'low') else '--inputBufferSize 10000000' # for pairtools 1.0.0 and above run: - if wildcards.mode == "pairtools03": - shell(""" - soft/pairtools0.3.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ - soft/pairtools0.3.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ - soft/pairtools0.3.0/bin/pairtools sort --nproc {wildcards.cores} | \ - soft/pairtools0.3.0/bin/pairtools dedup -o {output.file} - """) - elif wildcards.mode == "pairtools1_bwamem2": + # if wildcards.mode == "pairtools03": + # shell(""" + # soft/pairtools0.3.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ + # soft/pairtools0.3.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ + # soft/pairtools0.3.0/bin/pairtools sort --nproc {wildcards.cores} | \ + # soft/pairtools0.3.0/bin/pairtools dedup -o {output.file} + # """) + if wildcards.mode == "pairtools_bwamem2": shell(""" soft/bwa-mem2/bwa-mem2 mem -t {wildcards.cores} -SP {input.genome_index_bwamem2} {input.fastq1} {input.fastq2} | \ soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ @@ -93,7 +104,7 @@ rule test: soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --backend {wildcards.regime} {params.chunksize_pairtools} \ -o {output.file} """) - elif wildcards.mode == "pairtools1": + elif wildcards.mode == "pairtools": shell(""" soft/pairtools1.0.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ @@ -112,23 +123,19 @@ rule test: shell(""" TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bwa} $TMP_FILE1 - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bwa} $TMP_FILE2 - samtools sort -@ {wildcards.cores} -n $TMP_FILE1 -o $TMP_FILE1.sorted - samtools sort -@ {wildcards.cores} -n $TMP_FILE2 -o $TMP_FILE2.sorted - soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted $TMP_FILE2.sorted {output.file} - rm $TMP_FILE1 $TMP_FILE1.sorted $TMP_FILE2 $TMP_FILE2.sorted + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bwa} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE1 + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bwa} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE2 + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1 $TMP_FILE2 {output.file} + rm $TMP_FILE1 $TMP_FILE2 """) elif wildcards.mode == "fanc_bowtie2": shell(""" TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bowtie2} $TMP_FILE1 - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bowtie2} $TMP_FILE2 - samtools sort -@ {wildcards.cores} -n $TMP_FILE1 -o $TMP_FILE1.sorted - samtools sort -@ {wildcards.cores} -n $TMP_FILE2 -o $TMP_FILE2.sorted - soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted $TMP_FILE2.sorted {output.file} - rm $TMP_FILE1 $TMP_FILE1.sorted $TMP_FILE2 $TMP_FILE2.sorted + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bowtie2} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE1 + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bowtie2} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE2 + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1 $TMP_FILE2 {output.file} + rm $TMP_FILE1 $TMP_FILE2 """) elif wildcards.mode == "hicpro": shell(""" diff --git a/examples/pairtools_restrict_walkthrough.ipynb b/examples/pairtools_restrict_walkthrough.ipynb new file mode 100644 index 00000000..ea3da16d --- /dev/null +++ b/examples/pairtools_restrict_walkthrough.ipynb @@ -0,0 +1,709 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a26ff7fa-0774-497c-8df8-4686845bf3b6", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "882425fb-e34a-41c7-8103-270da19ecec2", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker \n", + "import matplotlib.gridspec\n", + "import seaborn as sns\n", + "\n", + "%matplotlib inline\n", + "plt.style.use('seaborn-poster')\n", + "\n", + "import pandas as pd\n", + "import pairtools\n", + "import bioframe" + ] + }, + { + "cell_type": "markdown", + "id": "66194c2b-8c1b-4e21-80ef-1d2bf069199c", + "metadata": {}, + "source": [ + "# Pairtools: restriction walkthrough\n", + "\n", + "The common approach to analyse Hi-C data is based to analyse the contacts of the restriction fragments. It is used in *hiclib*, Juicer, HiC-Pro. \n", + "\n", + "Throughout this notebook, we will work with one of [Rao et al. 2014 datasets for IMR90 cells](https://data.4dnucleome.org/experiment-set-replicates/4DNES1ZEJNRU/) [1]. \n", + "\n", + "\n", + "[1] Rao, S. S., Huntley, M. H., Durand, N. C., Stamenova, E. K., Bochkov, I. D., Robinson, J. T., Sanborn, A. L., Machol, I., Omer, A. D., Lander, E. S., & Aiden, E. L. (2014). A 3D map of the human genome at kilobase resolution reveals principles of chromatin looping. Cell, 159(7), 1665–1680. https://doi.org/10.1016/j.cell.2014.11.021" + ] + }, + { + "cell_type": "markdown", + "id": "8a77207f-d444-4d5c-ab6c-1f2a1cf4c7b2", + "metadata": {}, + "source": [ + "### Download the data from 4DN portal\n", + "\n", + "To download the data from 4DN, you may need to [register, get key and secret and write a spceialized curl command for your user](https://data.4dnucleome.org/help/user-guide/downloading-files): " + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "a3d3eafc-5c28-40d4-be2a-8c4ba23e9809", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "100 330 100 330 0 0 931 0 --:--:-- --:--:-- --:--:-- 932\n", + "100 3395M 100 3395M 0 0 29.7M 0 0:01:54 0:01:54 --:--:-- 33.1M 0:01:48 0:00:12 0:01:36 32.8M\n" + ] + } + ], + "source": [ + "!curl -O -L --user RG6CSRMC:xlii3stnkphfygmu https://data.4dnucleome.org/files-processed/4DNFIW2BKSNF/@@download/4DNFIW2BKSNF.pairs.gz" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "22d0732a-9d6a-4957-8081-5cad5b3abf09", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Get total number of contacts to assess how many reads you can read in the future:\n", + "pairtools stats 4DNFIW2BKSNF.pairs.gz | head -n 1\n", + "# This will produce around 173 M pairs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff187814-015c-4f6a-b0e8-082161dfcef7", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Sample the fraction of pairs that will produce ~ 1 M of pairs:\n", + "pairtools sample 0.007 4DNFIW2BKSNF.pairs.gz -o 4DNFIW2BKSNF.pairs.sampled.gz" + ] + }, + { + "cell_type": "markdown", + "id": "e8a51837-c1a9-4c83-a140-8be9f8cbbbed", + "metadata": {}, + "source": [ + "#### Annotate restriction fragments" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61b32154-a8ec-48d1-9370-eaf6bc357e08", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Digest the genome into restriction fragments:\n", + "cooler digest ../tests_chromap/hg38/hg38.fa.sizes ../tests_chromap/hg38/hg38.fa MboI > hg38/hg38.MboI.restricted.bed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0699dee-a95f-4114-82c5-9758c74b5d27", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "# Annotate restriction fragments in the sampled file: \n", + "pairtools restrict -f hg38/hg38.MboI.restricted.bed 4DNFIW2BKSNF.pairs.sampled.gz -o 4DNFIW2BKSNF.pairs.sampled.restricted.gz" + ] + }, + { + "cell_type": "markdown", + "id": "34c594fe-41df-4f42-a25d-7c050f020fb2", + "metadata": {}, + "source": [ + "#### Read the pairs and analyse them as dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "309d3c54-7b2d-4a5e-a750-87eb0b6914d9", + "metadata": {}, + "outputs": [], + "source": [ + "from pairtools.lib import headerops, fileio" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "40daf717-6ffd-4c27-8b68-d553d458a713", + "metadata": {}, + "outputs": [], + "source": [ + "pairs_file = '4DNFIW2BKSNF.pairs.sampled.restricted.gz'" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6d363f7a-6053-488e-ad59-9df14260a7f6", + "metadata": {}, + "outputs": [], + "source": [ + "pairs_stream = fileio.auto_open(pairs_file, 'r')\n", + "header, pairs_stream = headerops.get_header(pairs_stream)\n", + "columns = headerops.get_colnames(header)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "deb04397-579b-4305-9dec-4f58e61e7ad4", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_table(pairs_stream, comment=\"#\", header=None)\n", + "df.columns = columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7688d530-4860-40e9-b865-affb7c35ccf1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "44d60718-dd56-4113-a409-57e5c1b882c0", + "metadata": {}, + "outputs": [], + "source": [ + "df.loc[:, 'dist_rfrag1_left'] = df.pos1 - df.rfrag_start1\n", + "df.loc[:, 'dist_rfrag1_right'] = df.rfrag_end1 - df.pos1\n", + "\n", + "df.loc[:, 'dist_rfrag2_left'] = df.pos2 - df.rfrag_start2\n", + "df.loc[:, 'dist_rfrag2_right'] = df.rfrag_end2 - df.pos2" + ] + }, + { + "cell_type": "markdown", + "id": "330e034a-e4f2-4deb-ab2c-9103e9083fa2", + "metadata": {}, + "source": [ + "Many of the 5'-ends of reads are mapped to the restriction sites: " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1a7ef073-082b-4aa6-972f-85ada84be4d4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xmin = 0\n", + "xmax = 2000\n", + "step = 20\n", + "\n", + "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_left, bins=np.arange(xmin, xmax, step), label='Distance from the 5\\' read end to the nearest upstream rsite, + mapped reads')\n", + "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_right, bins=np.arange(xmin, xmax, step), label='Distance from the 5\\' read end to the nearest downstream rsite, + mapped reads')\n", + "\n", + "plt.xlim(xmin, xmax)\n", + "plt.legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8fb2a16b-a921-4451-9250-4c0e381ac516", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xmin = 0\n", + "xmax = 200\n", + "step = 1\n", + "\n", + "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_left, bins=np.arange(xmin, xmax, step), label='Distance from the 5\\' read end to the nearest upstream rsite, + mapped reads')\n", + "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_right, bins=np.arange(xmin, xmax, step), label='Distance from the 5\\' read end to the nearest downstream rsite, + mapped reads')\n", + "\n", + "plt.xlim(xmin, xmax)\n", + "plt.legend()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "2cfd8a30-79d4-4926-b0e9-809ac185228c", + "metadata": {}, + "source": [ + "However, if we select only the pairs that map to the restriction sites, there is no significant skew in scaling:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "97eac9b5-2b51-4529-9056-48d061c30d6b", + "metadata": {}, + "outputs": [], + "source": [ + "hg38_chromsizes = bioframe.fetch_chromsizes('hg38', \n", + " as_bed=True)\n", + "hg38_cens = bioframe.fetch_centromeres('hg38')\n", + "hg38_arms = bioframe.make_chromarms(hg38_chromsizes, \n", + " dict(hg38_cens.set_index('chrom').mid), \n", + " cols_chroms=('chrom', 'start', 'end') )\n", + "\n", + "# To fix pandas bug in some versions: \n", + "hg38_arms['start'] = hg38_arms['start'].astype(int)\n", + "hg38_arms['end'] = hg38_arms['end'].astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "28358a56-a6fe-4ec7-9ca6-52822a6224b9", + "metadata": {}, + "outputs": [], + "source": [ + "import pairtools.lib.scaling as scaling" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3769c57b-78c7-48e4-85bf-710f7f459e1e", + "metadata": {}, + "outputs": [], + "source": [ + "def plot(cis_scalings, n, xlim=(1e1,1e9), label='' ):\n", + " strand_gb = cis_scalings.groupby(['strand1', 'strand2'])\n", + " for strands in ['+-', '-+', '++', '--']:\n", + " sc_strand = strand_gb.get_group(tuple(strands))\n", + " sc_agg = (sc_strand\n", + " .groupby(['min_dist','max_dist'])\n", + " .agg({'n_pairs':'sum', 'n_bp2':'sum'})\n", + " .reset_index())\n", + "\n", + " dist_bin_mids = np.sqrt(sc_agg.min_dist * sc_agg.max_dist)\n", + " pair_frequencies = sc_agg.n_pairs / sc_agg.n_bp2\n", + " pair_frequencies = pair_frequencies/cis_scalings.n_pairs.sum()\n", + " mask = pair_frequencies>0\n", + " label_long = f'{strands[0]}{strands[1]} {label}'\n", + "\n", + " if np.sum(mask)>0:\n", + " plt.loglog(\n", + " dist_bin_mids[mask],\n", + " pair_frequencies[mask],\n", + " label=label_long,\n", + " lw=2\n", + " )\n", + "\n", + " plt.gca().xaxis.set_major_locator(matplotlib.ticker.LogLocator(base=10.0,numticks=20))\n", + " plt.gca().yaxis.set_major_locator(matplotlib.ticker.LogLocator(base=10.0,numticks=20))\n", + " plt.gca().set_aspect(1.0)\n", + " plt.xlim(xlim)\n", + "\n", + " plt.grid(lw=0.5,color='gray')\n", + " plt.legend(loc=(1.1,0.4))\n", + " plt.ylabel('contact frequency, \\nHi-C molecule per bp pair normalized by total')\n", + " plt.xlabel('distance, bp')\n", + "\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bf07b649-d184-4ded-827b-d8ff3f9f4284", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Get the pairs where R1 is far enough from site of restriction, but not too far\n", + "df_subset = df.query(\"(strand1=='+' and dist_rfrag1_left>5 and dist_rfrag1_left<=250)\")\n", + "n_distant = len(df_subset)\n", + "cis_scalings_distant, trans_levels_distant = scaling.compute_scaling(\n", + " df_subset,\n", + " regions=hg38_arms,\n", + " chromsizes=hg38_arms,\n", + " dist_range=(10, 1e9), \n", + " n_dist_bins=128,\n", + " chunksize=int(1e7),\n", + " )\n", + "plot(cis_scalings_distant, n_distant, label=\"pairs, 5' distant from rsite\")\n", + "\n", + "\n", + "# Get the pairs where R1 is too far enough from site of restriction\n", + "df_subset = df.query(\"(strand1=='+' and dist_rfrag1_left>550)\")\n", + "n_toodistant = len(df_subset)\n", + "cis_scalings_toodistant, trans_levels_toodistant = scaling.compute_scaling(\n", + " df_subset,\n", + " regions=hg38_arms,\n", + " chromsizes=hg38_arms,\n", + " dist_range=(10, 1e9), \n", + " n_dist_bins=128,\n", + " chunksize=int(1e7),\n", + " )\n", + "plot(cis_scalings_toodistant, n_toodistant, label=\"pairs, 5' too far from rsite\")\n", + "\n", + "\n", + "# Get the pairs where R1 is very close to the site of restriction\n", + "df_subset = df.query(\"(strand1=='+' and dist_rfrag1_left<5)\")\n", + "n_tooclose = len(df_subset)\n", + "cis_scalings_tooclose, trans_levels_tooclose = scaling.compute_scaling(\n", + " df_subset,\n", + " regions=hg38_arms,\n", + " chromsizes=hg38_arms,\n", + " dist_range=(10, 1e9), \n", + " n_dist_bins=128,\n", + " chunksize=int(1e7),\n", + " )\n", + "plot(cis_scalings_tooclose, n_tooclose, label=\"pairs, 5' close to rsite\")\n", + "# Try another replicate of replicate, maybe the last one " + ] + }, + { + "cell_type": "markdown", + "id": "60967f0b-7f50-429f-8865-046d3fd0d878", + "metadata": {}, + "source": [ + "#### How many pairs we take if not strictly filtering by dangling ends and self-circles? " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bfb77fa0-85ee-4573-b745-57353b74f646", + "metadata": {}, + "outputs": [], + "source": [ + "df.loc[:, \"type_rfrag\"] = \"Regular pair\"\n", + "\n", + "mask_neighboring_rfrags = (np.abs(df.rfrag1-df.rfrag2)<=1)\n", + "\n", + "mask_DE = (df.strand1==\"+\") & (df.strand2==\"-\") & mask_neighboring_rfrags\n", + "df.loc[mask_DE, \"type_rfrag\"] = \"DanglingEnd\"\n", + "\n", + "mask_SS = (df.strand1==\"-\") & (df.strand2==\"+\") & mask_neighboring_rfrags\n", + "df.loc[mask_SS, \"type_rfrag\"] = \"SelfCircle\"\n", + "\n", + "mask_Err = (df.strand1==df.strand2) & mask_neighboring_rfrags\n", + "df.loc[mask_Err, \"type_rfrag\"] = \"Mirror\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c6913bb4-f861-4098-a193-94a134df4ea5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "type_rfrag\n", + "DanglingEnd 76902\n", + "Mirror 3214\n", + "Regular pair 1132002\n", + "SelfCircle 3036\n", + "Name: readID, dtype: int64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(\"type_rfrag\").groupby(\"type_rfrag\").count()['readID']" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c2e77360-e8ee-43c6-8322-b9990aef19bc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Full scaling\n", + "\n", + "n = len(df)\n", + "cis_scalings, trans_levels = scaling.compute_scaling(\n", + " df,\n", + " regions=hg38_arms,\n", + " chromsizes=hg38_arms,\n", + " dist_range=(10, 1e9), \n", + " n_dist_bins=128,\n", + " chunksize=int(1e7),\n", + " )\n", + "plot(cis_scalings, n, label=\"pairs\")\n", + "\n", + "# The point where the scalings by distance become balanced:\n", + "plt.axvline(2e3, ls='--', c='gray', label='Balancing point')\n", + "\n", + "plt.savefig(\"./oriented_scalings.pdf\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "a506a74c-230f-4219-9273-99b6f04e211d", + "metadata": {}, + "outputs": [], + "source": [ + "df.loc[:, \"type_bydist\"] = \"Regular pair\"\n", + "\n", + "mask_ondiagonal = (np.abs(df.pos2-df.pos1)<=2e3)\n", + "\n", + "mask_DE = (df.strand1==\"+\") & (df.strand2==\"-\") & mask_ondiagonal\n", + "df.loc[mask_DE, \"type_bydist\"] = \"DanglingEnd\"\n", + "\n", + "mask_SS = (df.strand1==\"-\") & (df.strand2==\"+\") & mask_ondiagonal\n", + "df.loc[mask_SS, \"type_bydist\"] = \"SelfCircle\"\n", + "\n", + "mask_Err = (df.strand1==df.strand2) & mask_ondiagonal\n", + "df.loc[mask_Err, \"type_bydist\"] = \"Mirror\"" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "255bda45-6a64-4795-a964-546e55d67145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "type_bydist\n", + "DanglingEnd 135381\n", + "Mirror 18383\n", + "Regular pair 1053213\n", + "SelfCircle 8177\n", + "Name: readID, dtype: int64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(\"type_bydist\").groupby(\"type_bydist\").count()['readID']" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "b628bdfb-abbf-45df-8f33-2056dc96f19f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
readID
type_bydistDanglingEndMirrorRegular pairSelfCircle
type_rfrag
DanglingEnd76898040
Mirror03176380
Regular pair584831520710529945318
SelfCircle001772859
\n", + "
" + ], + "text/plain": [ + " readID \n", + "type_bydist DanglingEnd Mirror Regular pair SelfCircle\n", + "type_rfrag \n", + "DanglingEnd 76898 0 4 0\n", + "Mirror 0 3176 38 0\n", + "Regular pair 58483 15207 1052994 5318\n", + "SelfCircle 0 0 177 2859" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values([\"type_rfrag\", \"type_bydist\"])\\\n", + " .groupby([\"type_rfrag\", \"type_bydist\"])\\\n", + " .count()[['readID']]\\\n", + " .reset_index()\\\n", + " .pivot(columns=\"type_bydist\", index=\"type_rfrag\")\\\n", + " .fillna(0).astype(int)" + ] + }, + { + "cell_type": "markdown", + "id": "23a56c6f-c2d1-48e4-9b2e-860622af5a3f", + "metadata": {}, + "source": [ + "False Positives are in 3rd row, False Negatives are in 3rd column. Filtering by distance is, thus, nearly as effective as filtering by restriction fragment, but removes additional pairs that can be potential undercut by restriction enzyme.\n", + "\n", + "Removing all contacts closer than 2 Kb will remove Hi-C artifacts." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10", + "language": "python", + "name": "python310" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From faf58783d5218120e948a0f0f1b9b90119028d8a Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 10 May 2022 21:09:11 -0400 Subject: [PATCH 43/52] Benchmarks finalization --- examples/benchmark/Snakefile | 118 +++--- examples/benchmark/benchmark.ipynb | 450 +++++++++++++---------- examples/benchmark/benchmarking_1mln.csv | 121 ++++++ 3 files changed, 421 insertions(+), 268 deletions(-) create mode 100644 examples/benchmark/benchmarking_1mln.csv diff --git a/examples/benchmark/Snakefile b/examples/benchmark/Snakefile index 1c6437c7..84351da1 100644 --- a/examples/benchmark/Snakefile +++ b/examples/benchmark/Snakefile @@ -1,68 +1,45 @@ -cores_choices = [1, 2, 4] -memory_choices = ["low", "high"] -# pairtools_versions = ["pairtools03", "pairtools1", "pairtools1_bwamem2"] +cores_choices = [1] #, 2, 4] chromap = expand( - "output/result.chromap.{memory}.{cores}.pairs", + "output/result.chromap.{cores}.pairs", cores=cores_choices, - memory=memory_choices, ) juicer = expand( - "output/result.juicer.{memory}.{cores}.pairs", + "output/result.juicer.{cores}.pairs", cores=cores_choices, - memory=["regular"], ) hicexplorer = expand( - "output/result.hicexplorer.{memory}.{cores}.cool", + "output/result.hicexplorer.{cores}.cool", cores=cores_choices, - memory=memory_choices, ) fanc_bwa = expand( - "output/result.fanc_bwa.{memory}.{cores}.pairs", + "output/result.fanc_bwa.{cores}.pairs", cores=cores_choices, - memory=["regular"], ) fanc_bowtie = expand( - "output/result.fanc_bowtie2.{memory}.{cores}.pairs", + "output/result.fanc_bowtie2.{cores}.pairs", cores=cores_choices, - memory=["regular"], ) hicpro = expand( - "output/result.hicpro.{memory}.{cores}.pairs", + "output/result.hicpro.{cores}.pairs", cores=cores_choices, - memory=["regular"], ) pairtools = expand( - "output/result.pairtools.{memory}.{cores}.pairs", + "output/result.pairtools.{cores}.pairs", cores=cores_choices, - memory=memory_choices, ) pairtools_bwamem2 = expand( - "output/result.pairtools_bwamem2.{memory}.{cores}.pairs", + "output/result.pairtools_bwamem2.{cores}.pairs", cores=cores_choices, - memory=memory_choices, ) -# pairtools_cython = expand( -# "output/result.{mode}.{regime}.{memory}.{cores}.pairs", -# regime=['cython'], -# mode=pairtools_versions, -# cores=cores_choices, -# memory=["regular"], -# ) -# pairtools_nocython = expand( -# "output/result.{mode}.{regime}.{memory}.{cores}.pairs", -# regime=['sklearn', 'scipy'], -# mode=pairtools_versions, -# cores=cores_choices, -# memory=memory_choices, -# ) rule all: input: - lambda wildcards: hicexplorer + hicpro -# fanc_bowtie + fanc_bwa + pairtools_cython + pairtools_nocython + chromap -# hicpro + -# + juicer # run separately with the number of cores equal to tested! + lambda wildcards: juicer #pairtools + pairtools_bwamem2 + chromap + hicpro + fanc_bowtie + fanc_bwa + hicexplorer + +# juicer # +# hicexplorer # heavy because it creates coolers +# juicer # run separately with the number of cores equal to tested! rule test: input: @@ -77,31 +54,19 @@ rule test: genome_rsites="data/hg38/hg38.DpnII.bed", threads: lambda wildcards: int(wildcards.cores), output: - file="output/result.{mode}.{memory}.{cores}.{format}", + file="output/result.{mode}.{cores}.{format}", benchmark: repeat( - "benchmarks/result.{mode}.{memory}.{cores}.{format}.benchmark", + "benchmarks/result.{mode}.{cores}.{format}.benchmark", 5, ) - params: - memory_chromap = lambda wildcards: '--low-mem' if (wildcards.memory=='low') else '', # for chromap only - chunksize_pairtools = lambda wildcards: '--chunksize 100000' if (wildcards.memory=='low') else '--chunksize 10000000', # for pairtools 1.0.0 and above - memory_hicpro = lambda wildcards: "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 100M/' $TMP_CONFIG" if (wildcards.memory=='low') else "sed -i 's/SORT_RAM = 1000M/SORT_RAM = 10000M/' $TMP_CONFIG", - chunksize_hicexplorer = lambda wildcards: '--inputBufferSize 100000' if (wildcards.memory == 'low') else '--inputBufferSize 10000000' # for pairtools 1.0.0 and above run: - # if wildcards.mode == "pairtools03": - # shell(""" - # soft/pairtools0.3.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ - # soft/pairtools0.3.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ - # soft/pairtools0.3.0/bin/pairtools sort --nproc {wildcards.cores} | \ - # soft/pairtools0.3.0/bin/pairtools dedup -o {output.file} - # """) if wildcards.mode == "pairtools_bwamem2": shell(""" soft/bwa-mem2/bwa-mem2 mem -t {wildcards.cores} -SP {input.genome_index_bwamem2} {input.fastq1} {input.fastq2} | \ soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ soft/pairtools1.0.0/bin/pairtools sort --nproc {wildcards.cores} | \ - soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --backend {wildcards.regime} {params.chunksize_pairtools} \ + soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --chunksize 1000000 \ -o {output.file} """) elif wildcards.mode == "pairtools": @@ -109,47 +74,50 @@ rule test: soft/pairtools1.0.0/bin/bwa mem -t {wildcards.cores} -SP {input.genome_index_bwa} {input.fastq1} {input.fastq2} | \ soft/pairtools1.0.0/bin/pairtools parse --nproc-in {wildcards.cores} --nproc-out {wildcards.cores} --drop-sam --drop-seq -c {input.chromsizes} | \ soft/pairtools1.0.0/bin/pairtools sort --nproc {wildcards.cores} | \ - soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --backend {wildcards.regime} {params.chunksize_pairtools} \ + soft/pairtools1.0.0/bin/pairtools dedup -p {wildcards.cores} --chunksize 1000000 \ -o {output.file} """) elif wildcards.mode == "chromap": shell(""" - soft/chromap/bin/chromap --preset hic {params.memory_chromap}\ + soft/chromap/bin/chromap --preset hic \ -t {wildcards.cores} -x {input.genome_index_chromap} -r {input.genomefile} \ -1 {input.fastq1} -2 {input.fastq2} -o {output.file} """) elif wildcards.mode == "fanc_bwa": shell(""" - TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) - TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bwa} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE1 - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bwa} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE2 - soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1 $TMP_FILE2 {output.file} - rm $TMP_FILE1 $TMP_FILE2 + TMP_FILE1=$(mktemp -u output/tmp.XXXXXXXX.bam) + TMP_FILE2=$(mktemp -u output/tmp.XXXXXXXX.bam) + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bwa} $TMP_FILE1 + samtools sort -n -@ {wildcards.cores} $TMP_FILE1 -o $TMP_FILE1.sorted.bam + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bwa} $TMP_FILE2 + samtools sort -n -@ {wildcards.cores} $TMP_FILE2 -o $TMP_FILE2.sorted.bam + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted.bam $TMP_FILE2.sorted.bam {output.file} + rm $TMP_FILE1 $TMP_FILE2 $TMP_FILE1.sorted.bam $TMP_FILE2.sorted.bam """) elif wildcards.mode == "fanc_bowtie2": shell(""" - TMP_FILE1=$(mktemp output/tmp.XXXXXXXX.bam) - TMP_FILE2=$(mktemp output/tmp.XXXXXXXX.bam) - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bowtie2} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE1 - soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bowtie2} | samtools sort -@ {wildcards.cores} - -o $TMP_FILE2 - soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1 $TMP_FILE2 {output.file} - rm $TMP_FILE1 $TMP_FILE2 + TMP_FILE1=$(mktemp -u output/tmp.XXXXXXXX.bam) + TMP_FILE2=$(mktemp -u output/tmp.XXXXXXXX.bam) + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq1} {input.genome_index_bowtie2} $TMP_FILE1 + samtools sort -n -@ {wildcards.cores} $TMP_FILE1 -o $TMP_FILE1.sorted.bam + soft/fanc/bin/fanc map -t {wildcards.cores} {input.fastq2} {input.genome_index_bowtie2} $TMP_FILE2 + samtools sort -n -@ {wildcards.cores} $TMP_FILE2 -o $TMP_FILE2.sorted.bam + soft/fanc/bin/fanc pairs -f -g {input.genome_rsites} $TMP_FILE1.sorted.bam $TMP_FILE2.sorted.bam {output.file} + rm $TMP_FILE1 $TMP_FILE2 $TMP_FILE1.sorted.bam $TMP_FILE2.sorted.bam """) elif wildcards.mode == "hicpro": shell(""" cd soft/HiC-Pro_env/HiC-Pro/ - TMP_CONFIG=$(mktemp output/tmp.XXXXXXXX) - TMP_DIR=$(mktemp -d output/tmp.XXXXXXXX) + TMP_CONFIG=$(mktemp -u output/tmp.XXXXXXXX) + TMP_DIR=$(mktemp -d -u output/tmp.XXXXXXXX) cp config-hicpro.txt $TMP_CONFIG sed -i 's/N_CPU = 4/N_CPU = {wildcards.cores}/' $TMP_CONFIG - {params.memory_hicpro} bin/HiC-Pro -i rawdata/ -o $TMP_DIR -c $TMP_CONFIG # Cleanup: - cp $TMP_DIR/hic_results/data/sample1/sample1.allValidPairs {output.file} + cp $TMP_DIR/hic_results/data/sample1/sample1.allValidPairs ../../../{output.file} rm -r $TMP_DIR $TMP_CONFIG """) elif wildcards.mode == "juicer": @@ -161,13 +129,11 @@ rule test: # Cleanup: mv data/4juicer/aligned/merged_nodups.txt {output.file} - rm -rf data/4juicer/aligned data/4juicer/splits/*[^q] + rm -rf data/4juicer/aligned; rm -rf data/4juicer/splits/[^S]* """) elif wildcards.mode == "hicexplorer": - # Note that this process is not guaranteed to work well in parallel mode; - # recommended to run separately shell(""" - TMP_DIR=$(mktemp -d output/tmp.XXXXXXXX) + TMP_DIR=$(mktemp -d -u output/tmp.XXXXXXXX) soft/hicexplorer/bin/hicBuildMatrix --samFiles \ <(bwa mem -A1 -B4 -E50 -L0 {input.genome_index_bwa} -t {wildcards.cores} data/SRR6107789_1.fastq.gz | samtools view -@ {wildcards.cores} -Shb -) \ @@ -176,10 +142,10 @@ rule test: --danglingSequence GATC \ --restrictionCutFile {input.genome_rsites} \ --threads {wildcards.cores} \ - {params.chunksize_hicexplorer} \ + --inputBufferSize 1000000 \ --QCfolder $TMP_DIR \ -o {output.file} - + # Cleanup: rm -r $TMP_DIR """) diff --git a/examples/benchmark/benchmark.ipynb b/examples/benchmark/benchmark.ipynb index 37859570..ccc378f3 100644 --- a/examples/benchmark/benchmark.ipynb +++ b/examples/benchmark/benchmark.ipynb @@ -3,38 +3,63 @@ { "cell_type": "markdown", "id": "864d317a-4960-4315-846d-ba2f36014614", - "metadata": {}, + "metadata": { + "tags": [] + }, "source": [ "# Pairtools benchmarking\n", "\n", - "Welcome to pairtools benchmarking.\n", + "Welcome to pairtools benchmarking. These are the instructions on how to test performance of different software for mapping Hi-C and Hi-C-like methods.\n", + "Mapping usually results in the file with mapped pairs, which is then converted into binned matrix format. Pairs format is the \"rawest\" interpretable type of data after reads.\n", + "\n", + "Reviewing the literature suggests that there are at least 6 methods to map Hi-C and Hi-C-like data. These include:\n", + "\n", + "- **pairtools** is a lightweight Python CLI that extracts and manipulates Hi-C contacts post-alignment. Aslignment can be done by:\n", + " - bwa mem\n", + " - bwa-mem2, ahn optimized version of bwa mem, which [x2-2.5 improves speed over bwa](https://github.com/bwa-mem2/bwa-mem2)\n", + "\n", + "- **chromap** is a [fast alignment tool for chromatin profiles](https://www.nature.com/articles/s41467-021-26865-w), not specialized for Hi-C but [parameterized for a broad range of sequencing data including Hi-C short reads](https://github.com/haowenz/chromap#map-hi-c-short-reads). \n", + "\n", + " Does not require separate step of mapping.\n", "\n", - "We will test performance of different software for mapping Hi-C and Hi-C-like methods:\n", + "- **HiC-Pro** is a [pipeline for Hi-C and DNase-C mapping](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-015-0831-x), \"optimized and flexible\".\n", "\n", - "- bwa mem and pairtools\n", + " It calls mapping within. By default, creates the output cooler files with binned data, but the script can be tinkered in order to stop the processing at the step of pairs. \n", "\n", - "- bwa-mem2 and pairtools\n", + "- **Juicer** is a [platform for analysis of Hi-C data](https://github.com/aidenlab/juicer), which is already adapted to a wide range of cluster types.\n", "\n", - "- chromap\n", + " It calls mapping within. Has an option to stop the data processing at the step of pairs, without further construction of binned matrices. \n", "\n", - "- HiC-Pro\n", + "- **HiCExplorer** is a [broad-range set of tools for processing, normalization, analysis and visualization Hi-C and Hi-C-like methods](https://doi.org/10.1038/s41467-017-02525-w). \n", "\n", - "- Juicer\n", + " It [builds Hi-C binned matrix post-alignment with bwa mem](https://hicexplorer.readthedocs.io/en/latest/content/tools/hicBuildMatrix.html#hicbuildmatrix). \n", "\n", - "- FAN-C\n", + "- **FAN-C** is a [set of CLI tools that runs the mapping (bowtie or bwa mem), extracts and manipulates Hi-C contacts](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-020-02215-9). It also has the [tools for data visualization and downstream analysis](https://github.com/vaquerizaslab/fanc).\n", "\n", - "- HiCExplorer\n", "\n", + "*We benchmark these programs on one million of representative reads.*\n", + "These reads are taken from random replicate from Rao SSP et al., [\"Cohesin Loss Eliminates All Loop Domains.\"](https://pubmed.ncbi.nlm.nih.gov/28985562/), Cell, 2017 Oct 5;171(2):305-320.e24\n", + "
\n", + "Generally, it is useful to assess how much computational time you need per million of reads.\n", + "
\n", + "As long as you have this assessment, you may multiply the size of your experiment by the whole library size (in mlns of reads), because we expect linear growth of computational complexity of reads mapping with library size.\n", "\n", - "The outline:\n", "\n", - "1. [Install software](#Install-software)\n", + "The benchmarking consists of four general steps. If you want to reproduce it, you need to run steps 1 and 2 manually in order to create the working environment, and then use snakemake script to run the benchmarks. \n", + "
\n", + "You may use the commands form the \"3. Run\" section to get an understanding how each indiviaul framework works and what parameters can be changed. \n", + "
\n", + "Note that you need separate run of juicer with single value of --ncores, because it does not support parallel launches (because it writes to the default output).\n", + "
\n", + "Finally, there is a visualization section with a display of all the results that we calcualted on our machines. \n", "\n", - "2. [Download data and genome](#Download-data-and-genome)\n", + "1. [Install software](#1.-Install-software)\n", "\n", - "3. [Run](#Run)\n", + "2. [Download data and genome](#2.-Download-data-and-genome). \n", "\n", - "4. [Visualize benchmarks](#Visualize-benchmarks)" + "3. [Run](#3.-Run)\n", + "\n", + "4. [Visualize benchmarks](#4.-Visualize-benchmarks)\n" ] }, { @@ -42,7 +67,7 @@ "id": "8ae7b1ea-f64b-4740-8694-2fdb1d7353c4", "metadata": {}, "source": [ - "## Install software\n", + "## 1. Install software\n", "\n", "We will use separate conda environments to install different utilities. Each utility will have its own environment and peth to the binaries." ] @@ -58,21 +83,6 @@ "mkdir ./soft" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "5128b353-cb8a-4d67-b6af-a9d7f730bbdf", - "metadata": {}, - "outputs": [], - "source": [ - "# Consider adding: https://hicexplorer.readthedocs.io/en/latest/content/tools/hicBuildMatrix.html#hicbuildmatrix\n", - "### HiCExplorer\n", - "\n", - "# conda install hicexplorer -c bioconda -c conda-forge\n", - "\n", - "# hicBuildMatrix" - ] - }, { "cell_type": "markdown", "id": "b9dc2f27-868f-4bfd-bd9f-d88d18d6655f", @@ -81,34 +91,12 @@ "### pairtools" ] }, - { - "cell_type": "markdown", - "id": "a9d26560-7035-44c5-bf8c-f4f9d4c63794", - "metadata": {}, - "source": [ - "#### pairtools v 0.3.0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e0e2ac73-18c4-445f-a3f5-142f79d67ae0", - "metadata": {}, - "outputs": [], - "source": [ - "%%bash\n", - "conda create -y --prefix soft/pairtools0.3.0 python=3.9 pip\n", - "conda activate soft/pairtools0.3.0\n", - "conda install -y -c conda-forge -c bioconda \"pairtools=0.3.0\"\n", - "conda install -y -c bioconda \"bwa>=0.7.17\"" - ] - }, { "cell_type": "markdown", "id": "cd56a6ab-3836-445c-ab70-73eaa4e80da8", "metadata": {}, "source": [ - "#### pairtools v 1.0.0" + "#### pairtools v1.0.0" ] }, { @@ -131,8 +119,7 @@ "id": "a7548c59-7cd2-40f8-85da-7a6b2ede143d", "metadata": {}, "source": [ - "#### Install bwa-mem2\n", - "[bwa-mem2](https://github.com/bwa-mem2/bwa-mem2) has significantly improved performance while having the same results. " + "#### bwa-mem2" ] }, { @@ -309,6 +296,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "conda create -y --prefix soft/hicexplorer python=3.9\n", "conda activate soft/hicexplorer\n", "conda install -y -c bioconda hicexplorer bwa" @@ -319,7 +308,7 @@ "id": "e325db7c-93d8-4e48-9ba6-8867956398cd", "metadata": {}, "source": [ - "## Download data and genome" + "## 2. Download data and genome" ] }, { @@ -329,6 +318,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "mkdir data" ] }, @@ -349,6 +340,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "fastq-dump -O data --gzip --split-files SRR6107789 --minSpotId 0 --maxSpotId 1000000" ] }, @@ -359,6 +352,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Put the data in accessible folder for juicer: \n", "mkdir -p data/4juicer/fastq/\n", "mkdir -p data/4juicer/splits/\n", @@ -374,6 +369,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Put the data in accessible folder for HiC-Pro:\n", "mkdir -p soft/HiC-Pro_env/HiC-Pro/rawdata/sample1\n", "cp data/S*fastq.gz soft/HiC-Pro_env/HiC-Pro/rawdata/sample1/" @@ -403,6 +400,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Activate bwa plugin for genomepy:\n", "! genomepy plugin enable bwa bowtie2" ] @@ -414,6 +413,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Install hg38 genome by genomepy:\n", "! genomepy install hg38 -g data/" ] @@ -425,8 +426,10 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Restrict the genome:\n", - "! cooler digest data/hg38/hg38.fa.sizes data/hg38/hg38.fa DpnII -o data/hg38/hg38.DpnII.bed" + "! cooler digest data/hg38/hg38.fa.sizes data/hg38/hg38.fa DpnII --rel-ids 1 -o data/hg38/hg38.DpnII.bed" ] }, { @@ -478,7 +481,7 @@ "id": "5a9bd0a9-9dc0-4942-bb1b-cf7b77363bb6", "metadata": {}, "source": [ - "## Run\n", + "## 3. Run\n", "\n", "The banchmarking is usually cumbersome, but it can be simplified by snakemake. We provide a Snakemake pipeline that will allow you to benchmark different approaches.\n", "\n", @@ -494,6 +497,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Running \n", "snakemake --cores 10" ] @@ -505,6 +510,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "# Cleanup\n", "rm output/*; rm benchmarks/*" ] @@ -534,6 +541,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "soft/bwa-mem2/bwa-mem2 mem -t 5 -SP data/hg38/index/bwa-mem2/hg38 data/SRR6107789_1.fastq.gz data/SRR6107789_2.fastq.gz | \\\n", " soft/pairtools1.0.0/bin/pairtools parse --nproc-in 5 --nproc-out 5 --drop-sam --drop-seq -c data/hg38/hg38.fa.sizes | \\\n", " soft/pairtools1.0.0/bin/pairtools sort --nproc 5 | \\\n", @@ -556,6 +565,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "soft/chromap/bin/chromap --preset hic --low-mem \\\n", " -t 5 -x data/hg38/index/chromap/hg38 -r data/hg38/hg38.fa \\\n", " -1 data/SRR6107789_1.fastq.gz -2 data/SRR6107789_2.fastq.gz -o output/result.chromap.pairs" @@ -576,6 +587,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "cd soft/HiC-Pro_env/HiC-Pro\n", "bin/HiC-Pro -i rawdata/ -o output -c config-hicpro.txt\n", "\n", @@ -598,6 +611,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "fanc map -t 5 data/SRR6107789_1.fastq.gz data/hg38/index/bwa/hg38.fa output/fanc-output_1.bam\n", "fanc map -t 5 data/SRR6107789_2.fastq.gz data/hg38/index/bwa/hg38.fa output/fanc-output_2.bam\n", "samtools sort -@ 5 -n output/fanc-output_1.bam -o output/fanc-output_1.sorted.bam\n", @@ -620,6 +635,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "soft/juicer-1.6/CPU/juicer.sh -g hg38 -d data/4juicer/ -s DpnII -S early -p data/hg38/hg38.fa.sizes -y data/hg38/hg38.DpnII.bed -z data/hg38/index/bwa/hg38.fa -t 5 -D soft/juicer-1.6/CPU" ] }, @@ -639,6 +656,8 @@ "metadata": {}, "outputs": [], "source": [ + "%%bash\n", + "\n", "hicBuildMatrix --samFiles \\\n", " <(bwa mem -t 4 -A1 -B4 -E50 -L0 data/hg38/index/bwa/hg38.fa data/SRR6107789_1.fastq.gz | samtools view -Shb -) \\\n", " <(bwa mem -t 4 -A1 -B4 -E50 -L0 data/hg38/index/bwa/hg38.fa data/SRR6107789_2.fastq.gz | samtools view -Shb -) \\\n", @@ -656,40 +675,61 @@ "id": "9b3b93e5-47b1-408f-a4d5-32a85060fd8a", "metadata": {}, "source": [ - "## Visualize benchmarks" + "## 4. Visualize benchmarks" ] }, { "cell_type": "code", "execution_count": 1, - "id": "5a59f6bc-be2d-442b-b4ac-07237f38c38b", + "id": "8eb57b57-db42-420a-a2e7-631fda0676e4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36 CPUs at 1388 GHz\n" + ] + } + ], "source": [ - "import pandas as pd\n", - "import seaborn as sns\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" + "# Check the CPU properties:\n", + "import psutil\n", + "print(f\"{psutil.cpu_count()} CPUs at {psutil.cpu_freq().current:.0f} GHz\") " ] }, { "cell_type": "code", "execution_count": 2, - "id": "bbf69dd7-919d-4f41-82ea-ff7138c6c62e", + "id": "5a59f6bc-be2d-442b-b4ac-07237f38c38b", "metadata": {}, "outputs": [], "source": [ - "%matplotlib inline" + "import pandas as pd\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "mpl.rcParams['font.family'] = \"sans-serif\"\n", + "figsize_A4 = np.array([11.69, 8.27])\n", + "plt.rcParams[\"figure.figsize\"] = figsize_A4.T\n", + "plt.rcParams['figure.facecolor']='white'\n", + "plt.rcParams['font.size']=16\n", + "\n", + "import glob" ] }, { "cell_type": "code", "execution_count": 3, - "id": "1674f09e-e258-4752-a029-2b109321f9d9", + "id": "986fae72-ac93-4bff-9749-3b3a70057e17", "metadata": {}, "outputs": [], "source": [ - "import glob" + "## If you start from .csv. file: \n", + "# df = pd.read_csv('benchmarking_1mln.csv')" ] }, { @@ -697,14 +737,24 @@ "execution_count": 4, "id": "dd9e829a-f25e-4c66-b22d-01e008143396", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24\n" + ] + } + ], "source": [ - "files = glob.glob(\"benchmarks/*\")" + "# If you start from your own benchmarks:\n", + "files = glob.glob(\"benchmarks/*\")\n", + "print(len(files))" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "08707677-e087-44ca-8e8a-9d74ef4482a4", "metadata": {}, "outputs": [], @@ -712,23 +762,21 @@ "def get_params(filename):\n", " split = filename.split('.')\n", " util= split[1]\n", - " regime = split[2]\n", - " memory = split[3]\n", - " ncores = int(split[4])\n", + " ncores = int(split[2])\n", " \n", - " return util, regime, memory, ncores\n", + " return util, ncores\n", "\n", "timings = []\n", "for f in files:\n", " t = pd.read_table(f)\n", - " t[['util', 'regime', 'memory', 'ncores']] = get_params(f)\n", + " t[['util', 'ncores']] = get_params(f)\n", " timings.append(t)\n", "timings = pd.concat(timings)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "d43f8549-4765-441c-b94c-eb76a950ca4d", "metadata": {}, "outputs": [ @@ -764,95 +812,83 @@ " mean_load\n", " cpu_time\n", " util\n", - " regime\n", - " memory\n", " ncores\n", " \n", " \n", " \n", " \n", " 0\n", - " 2232.2865\n", - " 0:37:12\n", - " 5496.66\n", - " 8171.81\n", - " 5424.34\n", - " 5429.77\n", - " 12137.59\n", + " 550.4871\n", + " 0:09:10\n", + " 16937.49\n", + " 20627.90\n", + " 16934.21\n", + " 16935.80\n", + " 17020.73\n", " 0.02\n", - " 71.36\n", - " 1593.63\n", - " pairtools03\n", - " sklearn\n", - " low\n", + " 88.39\n", + " 487.29\n", + " pairtools_bwamem2\n", " 1\n", " \n", " \n", " 1\n", - " 1600.8423\n", - " 0:26:40\n", - " 5449.21\n", - " 8171.81\n", - " 5443.50\n", - " 5444.03\n", - " 19172.39\n", - " 39.25\n", - " 83.87\n", - " 1356.28\n", - " pairtools03\n", - " sklearn\n", - " low\n", + " 503.9536\n", + " 0:08:23\n", + " 17072.92\n", + " 20436.13\n", + " 16938.75\n", + " 16976.63\n", + " 33640.28\n", + " 64.62\n", + " 93.32\n", + " 21.95\n", + " pairtools_bwamem2\n", " 1\n", " \n", " \n", " 2\n", - " 1439.1596\n", - " 0:23:59\n", - " 5446.20\n", - " 8171.81\n", - " 5444.19\n", - " 5444.87\n", - " 27448.73\n", - " 84.00\n", - " 84.35\n", - " 43.03\n", - " pairtools03\n", - " sklearn\n", - " low\n", + " 501.0463\n", + " 0:08:21\n", + " 16962.04\n", + " 20820.16\n", + " 16908.41\n", + " 16909.56\n", + " 50288.75\n", + " 78.47\n", + " 95.58\n", + " 495.06\n", + " pairtools_bwamem2\n", " 1\n", " \n", " \n", " 3\n", - " 1045.3655\n", - " 0:17:25\n", - " 5574.15\n", - " 8171.81\n", - " 5512.73\n", - " 5517.64\n", - " 27467.57\n", - " 117.71\n", - " 101.11\n", - " 1095.38\n", - " pairtools03\n", - " sklearn\n", - " low\n", + " 497.2351\n", + " 0:08:17\n", + " 16973.35\n", + " 20820.14\n", + " 16905.40\n", + " 16921.17\n", + " 66884.51\n", + " 117.70\n", + " 95.54\n", + " 500.87\n", + " pairtools_bwamem2\n", " 1\n", " \n", " \n", " 4\n", - " 1031.9171\n", - " 0:17:11\n", - " 5574.22\n", - " 8171.81\n", - " 5512.79\n", - " 5517.93\n", - " 27467.58\n", + " 479.1700\n", + " 0:07:59\n", + " 16995.29\n", + " 20756.20\n", + " 16902.00\n", + " 16903.00\n", + " 83578.67\n", " 156.94\n", - " 102.40\n", - " 1106.47\n", - " pairtools03\n", - " sklearn\n", - " low\n", + " 97.32\n", + " 49.76\n", + " pairtools_bwamem2\n", " 1\n", " \n", " \n", @@ -860,22 +896,22 @@ "" ], "text/plain": [ - " s h:m:s max_rss max_vms max_uss max_pss io_in io_out \\\n", - "0 2232.2865 0:37:12 5496.66 8171.81 5424.34 5429.77 12137.59 0.02 \n", - "1 1600.8423 0:26:40 5449.21 8171.81 5443.50 5444.03 19172.39 39.25 \n", - "2 1439.1596 0:23:59 5446.20 8171.81 5444.19 5444.87 27448.73 84.00 \n", - "3 1045.3655 0:17:25 5574.15 8171.81 5512.73 5517.64 27467.57 117.71 \n", - "4 1031.9171 0:17:11 5574.22 8171.81 5512.79 5517.93 27467.58 156.94 \n", + " s h:m:s max_rss max_vms max_uss max_pss io_in \\\n", + "0 550.4871 0:09:10 16937.49 20627.90 16934.21 16935.80 17020.73 \n", + "1 503.9536 0:08:23 17072.92 20436.13 16938.75 16976.63 33640.28 \n", + "2 501.0463 0:08:21 16962.04 20820.16 16908.41 16909.56 50288.75 \n", + "3 497.2351 0:08:17 16973.35 20820.14 16905.40 16921.17 66884.51 \n", + "4 479.1700 0:07:59 16995.29 20756.20 16902.00 16903.00 83578.67 \n", "\n", - " mean_load cpu_time util regime memory ncores \n", - "0 71.36 1593.63 pairtools03 sklearn low 1 \n", - "1 83.87 1356.28 pairtools03 sklearn low 1 \n", - "2 84.35 43.03 pairtools03 sklearn low 1 \n", - "3 101.11 1095.38 pairtools03 sklearn low 1 \n", - "4 102.40 1106.47 pairtools03 sklearn low 1 " + " io_out mean_load cpu_time util ncores \n", + "0 0.02 88.39 487.29 pairtools_bwamem2 1 \n", + "1 64.62 93.32 21.95 pairtools_bwamem2 1 \n", + "2 78.47 95.58 495.06 pairtools_bwamem2 1 \n", + "3 117.70 95.54 500.87 pairtools_bwamem2 1 \n", + "4 156.94 97.32 49.76 pairtools_bwamem2 1 " ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -886,72 +922,102 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 7, "id": "ba0c1c4f-ac4c-43f5-8245-e32d1d4cc3cf", "metadata": {}, "outputs": [], "source": [ - "df = timings.sort_values(['ncores', 'util', 'regime', 'memory'])\n", - "df.loc[:, \"method\"] = df.apply(lambda x: f'{x.util}.{x.regime}', axis=1)" + "df = timings.sort_values(['ncores', 'util'])" ] }, { "cell_type": "code", - "execution_count": 30, - "id": "8f31f3be-cf8f-4976-9a60-28e97c13593d", + "execution_count": 8, + "id": "8b20d808-78aa-4efc-9c2d-999b4e393968", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.figure(figsize=[10,10])\n", - "ax = sns.barplot(x=\"s\", y=\"method\", data=df.query('ncores==2'), orient='h')\n", - "plt.xscale('log')" + "labels = ['chromap', 'pairtools_bwamem2', 'pairtools', 'juicer', 'hicpro', 'hicexplorer', 'fanc_bwa', 'fanc_bowtie2']\n", + "labels_mod = ['Chromap', 'bwa-mem2 + pairtools', 'pairtools', 'Juicer', 'Hi-Pro', 'HiCExplorer', 'bwa mem + FANC', 'bowtie2 + FANC']" ] }, { "cell_type": "code", - "execution_count": 31, - "id": "ef137624-1bad-440e-bfaf-462dc42802bb", + "execution_count": 11, + "id": "8f31f3be-cf8f-4976-9a60-28e97c13593d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "plt.figure(figsize=[10,10])\n", - "ax = sns.barplot(x=\"max_rss\", y=\"method\", data=df.query('ncores==2'), orient='h')\n", - "plt.xscale('log')" + "fig, axes = plt.subplots(nrows=1, ncols=2, sharey=True)\n", + "\n", + "cmap = ['#3E9ADE', '#EF242B', '#9FC741']\n", + "\n", + "style_dict = dict(\n", + " orient='h',\n", + " palette=cmap,\n", + " edgecolor=\"k\",\n", + " linewidth=2.0,\n", + " errwidth=2.0,\n", + " capsize=0.07)\n", + "\n", + "ax = axes[0]\n", + "sns.barplot(x=\"s\", \n", + " y=\"util\", \n", + " data=df.sort_values('util'),\n", + " order=labels,\n", + " hue='ncores',\n", + " hue_order=[4,2,1],\n", + " ax=ax,\n", + " **style_dict\n", + ")\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('Time (sec)')\n", + "ax.set_yticklabels(labels_mod)\n", + "ax.get_legend().remove()\n", + "\n", + "ax = axes[1]\n", + "sns.barplot(x=\"max_rss\", \n", + " y=\"util\", \n", + " data=df.sort_values('util'),\n", + " order=labels,\n", + " hue='ncores',\n", + " hue_order=[4,2,1],\n", + " ax=ax,\n", + " **style_dict)\n", + "\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('Maximum Resident Set Size (MB)')\n", + "ax.set_yticklabels(labels_mod)\n", + "\n", + "fig.suptitle('Benchmark of different Hi-C mapping tools for 1 mln reads (5 iterations)', y=0.99)\n", + "\n", + "# (x, y, width, height)\n", + "bb = (fig.subplotpars.left, fig.subplotpars.top+0.002, fig.subplotpars.right-fig.subplotpars.left, 0.2)\n", + "ax.legend(bbox_to_anchor=bb, title=\"Number of cores\", loc=\"lower right\", ncol=3, borderaxespad=0., bbox_transform=fig.transFigure, frameon=False)\n", + "\n", + "plt.savefig(\"benchmarking_1mln.pdf\")" ] }, { "cell_type": "code", - "execution_count": null, - "id": "66a8ddab-050d-4949-bad3-e3ccdf6277d8", + "execution_count": 10, + "id": "06fa2f0b-1c9e-473b-bbdd-3157f1d81a1a", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "df.to_csv('benchmarking_1mln.csv')" + ] } ], "metadata": { diff --git a/examples/benchmark/benchmarking_1mln.csv b/examples/benchmark/benchmarking_1mln.csv new file mode 100644 index 00000000..5d76f995 --- /dev/null +++ b/examples/benchmark/benchmarking_1mln.csv @@ -0,0 +1,121 @@ +,s,h:m:s,max_rss,max_vms,max_uss,max_pss,io_in,io_out,mean_load,cpu_time,util,ncores +0,171.2557,0:02:51,18999.14,20579.61,18990.64,18991.51,14942.02,61.25,81.02,140.18,chromap,1 +1,161.8126,0:02:41,19010.55,20589.94,19002.19,19003.05,29831.66,88.35,72.64,122.87,chromap,1 +2,147.2525,0:02:27,19251.87,20844.66,19244.98,19245.37,41893.51,176.68,89.18,139.78,chromap,1 +3,160.351,0:02:40,19010.16,20589.94,19004.14,19004.56,56673.84,265.02,74.24,132.19,chromap,1 +4,152.5034,0:02:32,19141.59,20730.08,19134.09,19134.47,71454.04,353.35,83.52,144.57,chromap,1 +0,4855.3497,1:20:55,7145.98,8625.58,4280.6,5694.97,84744.18,9677.61,40.17,357.4,fanc_bowtie2,1 +1,4420.6342,1:13:40,8792.0,10553.59,5632.48,7170.15,84826.6,21028.33,40.93,403.24,fanc_bowtie2,1 +2,4413.6342,1:13:33,8986.25,10746.44,5820.09,7349.67,88484.2,30605.01,39.66,404.48,fanc_bowtie2,1 +3,4559.0604,1:15:59,6141.95,7904.18,3527.04,4518.52,88624.8,41149.18,41.73,450.43,fanc_bowtie2,1 +4,4393.466,1:13:13,7152.7,8624.96,4279.3,5706.18,89015.34,51967.05,38.75,461.44,fanc_bowtie2,1 +0,3442.774,0:57:22,8261.52,10037.99,5748.96,6683.19,131784.28,6719.15,36.21,372.2,fanc_bwa,1 +1,2918.0923,0:48:38,8458.16,10221.93,5850.96,6836.51,137226.62,14901.08,36.74,395.53,fanc_bwa,1 +2,2889.2381,0:48:09,9003.84,10766.77,5838.07,7375.76,138088.69,21904.57,34.85,399.67,fanc_bwa,1 +3,2880.8428,0:48:00,6171.75,8915.39,5744.7,5861.54,138088.84,29503.53,36.48,424.87,fanc_bwa,1 +4,2988.8879,0:49:48,7149.86,8919.81,5798.19,5915.55,155317.34,37105.8,38.44,479.9,fanc_bwa,1 +0,1045.5567,0:17:25,22050.28,23335.28,22049.03,22049.68,5638.59,0.02,127.91,540.64,hicexplorer,1 +1,958.0772,0:15:58,22177.91,23335.53,22164.75,22165.79,6268.91,0.52,139.3,550.06,hicexplorer,1 +2,963.7224,0:16:03,22113.03,23335.53,22089.17,22091.46,7024.13,1.54,140.39,592.27,hicexplorer,1 +3,959.7175,0:15:59,21686.32,23335.53,21656.57,21661.51,9478.18,1.54,135.8,583.09,hicexplorer,1 +4,940.8744,0:15:40,22269.25,23335.53,22239.02,22243.54,9608.0,2.05,142.33,606.96,hicexplorer,1 +0,1161.8769,0:19:21,6719.61,7397.61,6669.41,6673.14,1520.62,1090.28,186.36,81.7,hicpro,1 +1,1150.9484,0:19:10,6704.99,7397.85,6669.48,6672.07,2811.04,2215.77,188.62,103.79,hicpro,1 +2,1152.1775,0:19:12,6702.39,7397.86,6669.6,6672.11,4304.55,3341.27,187.76,115.02,hicpro,1 +3,1137.5632,0:18:57,6709.09,7397.86,6669.89,6676.28,4467.08,4466.36,185.66,112.54,hicpro,1 +4,1136.876,0:18:56,6709.15,7397.86,6670.27,6675.79,4467.09,5592.23,187.49,148.26,hicpro,1 +0,951.7772,0:15:51,5457.95,5857.16,5432.96,5439.95,0.0,2882.08,95.15,7.25,juicer,1 +1,946.1429,0:15:46,5458.0,16410.45,5433.02,5439.99,0.0,4613.73,92.49,14.04,juicer,1 +2,950.1664,0:15:50,5458.07,5857.16,5433.16,5440.17,0.2,7180.02,95.32,26.17,juicer,1 +3,1004.5055,0:16:44,5458.27,16410.45,5433.17,5439.37,0.2,10377.86,93.19,30.43,juicer,1 +4,1088.6224,0:18:08,5458.32,5857.16,5433.14,5439.08,0.2,13611.21,94.37,43.31,juicer,1 +0,1072.4285,0:17:52,5717.21,8780.34,5713.66,5714.95,2308.36,39.24,97.52,14.75,pairtools,1 +1,1030.5073,0:17:10,5740.62,8780.59,5716.69,5717.73,2498.25,39.24,101.82,1059.32,pairtools,1 +2,1036.0581,0:17:16,5775.23,8780.52,5715.32,5716.56,3765.92,78.47,101.11,1065.81,pairtools,1 +3,1024.7524,0:17:04,5844.32,8780.55,5718.34,5751.62,9090.16,117.7,101.78,1069.4,pairtools,1 +4,1016.9986,0:16:56,5853.04,8780.52,5720.52,5756.12,9169.49,163.28,101.0,48.76,pairtools,1 +0,550.4871,0:09:10,16937.49,20627.9,16934.21,16935.8,17020.73,0.02,88.39,487.29,pairtools_bwamem2,1 +1,503.9536,0:08:23,17072.92,20436.13,16938.75,16976.63,33640.28,64.62,93.32,21.95,pairtools_bwamem2,1 +2,501.0463,0:08:21,16962.04,20820.16,16908.41,16909.56,50288.75,78.47,95.58,495.06,pairtools_bwamem2,1 +3,497.2351,0:08:17,16973.35,20820.14,16905.4,16921.17,66884.51,117.7,95.54,500.87,pairtools_bwamem2,1 +4,479.17,0:07:59,16995.29,20756.2,16902.0,16903.0,83578.67,156.94,97.32,49.76,pairtools_bwamem2,1 +0,94.1938,0:01:34,19068.07,20678.57,19047.6,19052.58,14768.99,0.02,119.14,113.62,chromap,2 +1,77.7396,0:01:17,19045.91,20665.29,19025.18,19029.89,14768.99,88.35,112.3,92.39,chromap,2 +2,77.1351,0:01:17,19045.99,20665.54,19025.28,19029.69,14768.99,176.68,113.29,98.83,chromap,2 +3,77.6121,0:01:17,19046.05,20665.54,19025.38,19029.77,14769.0,265.02,113.53,105.77,chromap,2 +4,77.5393,0:01:17,19045.89,20665.54,19025.11,19029.47,14769.0,353.35,112.5,111.44,chromap,2 +0,2606.2593,0:43:26,7169.49,8771.34,4283.19,5697.25,3509.66,9683.32,18.18,362.96,fanc_bowtie2,2 +1,2623.0423,0:43:43,8998.85,10977.97,5820.03,7368.32,3509.87,20209.78,19.39,389.26,fanc_bowtie2,2 +2,2560.5974,0:42:40,7169.39,8770.88,4284.44,5705.4,3509.88,30759.67,19.1,393.08,fanc_bowtie2,2 +3,2490.8813,0:41:30,7165.21,8769.02,4286.61,5705.35,4146.09,41263.6,18.05,379.78,fanc_bowtie2,2 +4,2567.7516,0:42:47,7163.99,8767.81,4331.13,5739.08,7999.79,51832.53,17.37,414.77,fanc_bowtie2,2 +0,1799.2042,0:29:59,9004.45,10989.12,5824.98,7362.88,24.79,6726.93,23.74,343.58,fanc_bwa,2 +1,1792.8877,0:29:52,7170.5,9286.24,5742.68,5861.39,24.87,14301.84,23.53,367.5,fanc_bwa,2 +2,1787.9905,0:29:47,7167.93,9286.07,5746.07,5884.19,5200.77,21894.25,24.17,379.1,fanc_bwa,2 +3,1786.0026,0:29:46,7167.34,9287.91,5746.42,5863.52,5200.79,29486.17,23.78,398.89,fanc_bwa,2 +4,1816.4364,0:30:16,7169.16,9285.9,5740.91,5854.21,5364.13,37082.73,24.02,424.26,fanc_bwa,2 +0,744.8584,0:12:24,22689.3,24488.74,22653.07,22661.19,0.0,0.02,162.18,520.73,hicexplorer,2 +1,739.6677,0:12:19,22848.0,24488.99,22811.35,22819.46,0.0,0.52,165.79,536.39,hicexplorer,2 +2,745.4914,0:12:25,22543.83,24488.99,22506.9,22515.17,0.0,1.03,156.08,550.24,hicexplorer,2 +3,735.0788,0:12:15,22745.13,24488.99,22707.45,22715.89,0.01,1.54,165.72,561.83,hicexplorer,2 +4,745.6433,0:12:25,22646.34,24488.99,22609.12,22617.68,0.07,2.05,156.73,570.12,hicexplorer,2 +0,1160.6621,0:19:20,6724.31,7397.86,6670.22,6681.32,237.58,1090.28,186.2,73.35,hicpro,2 +1,1157.5162,0:19:17,6724.37,7397.86,6670.52,6681.6,237.61,2215.77,188.28,96.48,hicpro,2 +2,1153.545,0:19:13,6724.21,7397.86,6670.41,6680.82,237.61,3341.26,188.33,111.24,hicpro,2 +3,1126.8091,0:18:46,6724.69,7397.86,6670.69,6681.04,237.61,4466.75,186.37,107.95,hicpro,2 +4,1123.4993,0:18:43,6724.44,7397.86,6670.7,6681.05,237.61,5592.23,187.78,127.18,hicpro,2 +0,502.114,0:08:22,5634.02,34265.69,5609.24,5616.47,70.82,2785.59,175.44,10.71,juicer,2 +1,502.401,0:08:22,5634.24,6057.17,5609.44,5616.5,70.89,5661.32,175.44,14.17,juicer,2 +2,502.5511,0:08:22,5634.45,6057.17,5609.73,5616.78,70.92,8537.05,175.43,18.41,juicer,2 +3,500.9428,0:08:20,5634.69,6057.17,5609.77,5616.84,70.92,11412.78,175.96,24.15,juicer,2 +4,500.3197,0:08:20,5634.83,6057.17,5610.01,5617.05,70.92,14367.65,176.2,21.5,juicer,2 +0,493.3558,0:08:13,6034.43,9532.37,5886.98,5926.35,119.25,0.02,197.44,976.1,pairtools,2 +1,495.0177,0:08:15,6035.91,9532.36,5888.32,5927.57,119.27,39.25,195.91,979.5,pairtools,2 +2,493.4662,0:08:13,6037.14,9532.62,5890.17,5931.54,119.27,78.48,196.67,986.39,pairtools,2 +3,495.3653,0:08:15,6036.7,9532.62,5888.86,5930.54,119.27,117.71,195.8,992.14,pairtools,2 +4,493.0538,0:08:13,6037.45,9532.61,5889.9,5931.07,119.27,156.94,196.7,998.26,pairtools,2 +0,269.5154,0:04:29,17364.26,22542.92,17216.99,17258.1,16458.32,0.02,184.0,497.96,pairtools_bwamem2,2 +1,264.1916,0:04:24,17370.49,21967.18,17221.91,17263.4,32731.18,39.26,169.33,14.67,pairtools_bwamem2,2 +2,242.8783,0:04:02,17374.63,22479.19,17226.26,17267.71,32731.18,78.48,202.03,504.14,pairtools_bwamem2,2 +3,240.312,0:04:00,17380.28,22584.26,17231.19,17272.84,32914.7,117.72,181.17,36.14,pairtools_bwamem2,2 +4,260.2244,0:04:20,17335.83,22287.18,17184.78,17226.53,43277.2,156.93,174.43,485.07,pairtools_bwamem2,2 +0,66.1876,0:01:06,18991.04,20714.05,18981.3,18983.05,14985.41,0.02,116.82,78.95,chromap,4 +1,66.4819,0:01:06,18990.63,20714.06,18981.04,18982.71,29925.57,88.35,117.9,82.69,chromap,4 +2,66.7036,0:01:06,18970.18,20708.46,18960.49,18962.16,44866.02,176.68,116.46,84.95,chromap,4 +3,64.9087,0:01:04,19042.49,20732.84,19032.81,19034.48,58828.13,265.02,127.11,92.57,chromap,4 +4,62.2284,0:01:02,19042.42,20730.94,19034.25,19035.61,71076.18,353.35,148.52,105.26,chromap,4 +0,1645.5116,0:27:25,8997.41,11419.24,5832.56,7402.09,3775.64,10271.72,28.18,370.43,fanc_bowtie2,4 +1,1619.9334,0:26:59,6157.95,8576.94,3572.04,4560.07,7664.87,20149.13,26.84,369.2,fanc_bowtie2,4 +2,1588.7391,0:26:28,7167.18,9050.39,4342.96,5747.66,7664.99,31081.43,30.88,374.4,fanc_bowtie2,4 +3,1586.9943,0:26:26,7164.36,9051.91,4339.34,5744.81,7699.56,41761.73,29.81,381.74,fanc_bowtie2,4 +4,1588.1941,0:26:28,7165.76,9051.89,4338.56,5745.02,7934.8,52165.17,30.26,393.88,fanc_bowtie2,4 +0,1217.6522,0:20:17,7164.02,9864.16,5755.11,5903.98,5725.82,6698.04,31.02,328.62,fanc_bwa,4 +1,1203.7575,0:20:03,7162.46,9864.08,5694.31,5844.12,5726.06,14297.14,36.35,359.69,fanc_bwa,4 +2,1209.304,0:20:09,9014.25,11434.79,5849.93,7419.8,5726.26,21891.89,36.77,360.09,fanc_bwa,4 +3,1209.9698,0:20:09,9019.61,11440.56,5857.24,7426.2,5726.32,29473.82,36.79,371.59,fanc_bwa,4 +4,1215.2228,0:20:15,9019.98,11439.18,5857.65,7426.89,5726.38,37068.11,36.41,379.67,fanc_bwa,4 +0,659.3963,0:10:59,23338.86,26170.54,23340.29,23340.77,358.09,0.52,163.06,550.72,hicexplorer,4 +1,687.6019,0:11:27,23725.26,26170.79,23724.7,23725.45,4611.54,1.03,171.24,574.94,hicexplorer,4 +2,690.3401,0:11:30,23709.58,26170.79,23689.0,23692.41,7829.07,1.54,176.44,581.15,hicexplorer,4 +3,671.4387,0:11:11,22807.14,26170.79,22787.6,22790.77,11022.66,1.54,184.36,572.08,hicexplorer,4 +4,669.665,0:11:09,22906.86,26170.79,22885.91,22889.43,14973.13,2.05,187.18,586.27,hicexplorer,4 +0,613.8815,0:10:13,6754.09,7622.23,6701.89,6712.25,480.14,1090.27,341.63,69.04,hicpro,4 +1,611.1198,0:10:11,6754.98,7622.49,6702.38,6714.12,480.16,2215.74,343.62,78.57,hicpro,4 +2,609.9385,0:10:09,6754.65,7622.49,6702.03,6712.67,480.17,3341.22,344.39,86.13,hicpro,4 +3,610.7242,0:10:10,6755.03,7622.48,6702.52,6714.04,505.8,4466.71,343.66,91.51,hicpro,4 +4,622.0769,0:10:22,6754.96,7622.48,6710.87,6718.84,506.52,5590.84,332.32,93.15,hicpro,4 +0,297.0198,0:04:57,5996.96,6457.18,5977.55,5979.61,3412.56,2785.59,297.18,6.35,juicer,4 +1,319.5797,0:05:19,5989.58,6457.18,5979.42,5981.48,9268.84,5739.07,309.19,7.78,juicer,4 +2,327.0335,0:05:27,5988.18,6457.18,5977.84,5978.92,10206.69,8537.05,311.25,12.23,juicer,4 +3,331.7378,0:05:31,5988.45,6457.18,5978.38,5979.71,16123.1,11364.07,297.09,18.28,juicer,4 +4,334.7347,0:05:34,5989.59,6457.18,5979.36,5980.55,19292.39,14066.95,290.47,19.62,juicer,4 +0,251.8315,0:04:11,6414.33,10892.68,6266.7,6308.41,5228.08,0.02,359.77,907.6,pairtools,4 +1,242.2713,0:04:02,6396.0,10828.75,6249.07,6290.71,5237.62,39.24,388.6,949.06,pairtools,4 +2,241.8187,0:04:01,6397.66,10828.74,6248.25,6290.61,5251.05,78.48,390.06,958.42,pairtools,4 +3,246.4631,0:04:06,6396.5,10892.75,6247.74,6289.48,10438.31,117.7,369.0,931.18,pairtools,4 +4,239.7562,0:03:59,6397.03,10828.68,6249.17,6290.98,10438.31,156.93,391.47,967.94,pairtools,4 +0,152.6922,0:02:32,17979.33,25543.29,17829.84,17871.88,16595.04,0.02,301.88,461.6,pairtools_bwamem2,4 +1,142.1458,0:02:22,17976.47,25223.34,17825.45,17867.58,27036.67,39.26,265.28,12.78,pairtools_bwamem2,4 +2,127.0336,0:02:07,17996.38,25159.3,17847.5,17890.06,27036.67,78.47,356.65,464.03,pairtools_bwamem2,4 +3,137.2203,0:02:17,18009.98,24643.06,17861.28,17903.91,32949.75,117.7,297.46,427.65,pairtools_bwamem2,4 +4,150.2599,0:02:30,17988.33,24331.95,17840.61,17882.52,49418.82,156.92,316.0,499.57,pairtools_bwamem2,4 From 3306195f687317d3c113ec7a915f184394dfe8fe Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 10 May 2022 21:32:16 -0400 Subject: [PATCH 44/52] benchmark fixes --- examples/benchmark/benchmark.ipynb | 100 +++++++++++++++++++++++++++-- 1 file changed, 95 insertions(+), 5 deletions(-) diff --git a/examples/benchmark/benchmark.ipynb b/examples/benchmark/benchmark.ipynb index ccc378f3..6604316f 100644 --- a/examples/benchmark/benchmark.ipynb +++ b/examples/benchmark/benchmark.ipynb @@ -646,7 +646,9 @@ "metadata": {}, "source": [ "### HiCExplorer\n", - "Based on the example: https://hicexplorer.readthedocs.io/en/latest/content/example_usage.html" + "Based on the example: https://hicexplorer.readthedocs.io/en/latest/content/example_usage.html\n", + "\n", + "Note that it does not procude the pairs, but binned coolers." ] }, { @@ -932,24 +934,24 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "id": "8b20d808-78aa-4efc-9c2d-999b4e393968", "metadata": {}, "outputs": [], "source": [ "labels = ['chromap', 'pairtools_bwamem2', 'pairtools', 'juicer', 'hicpro', 'hicexplorer', 'fanc_bwa', 'fanc_bowtie2']\n", - "labels_mod = ['Chromap', 'bwa-mem2 + pairtools', 'pairtools', 'Juicer', 'Hi-Pro', 'HiCExplorer', 'bwa mem + FANC', 'bowtie2 + FANC']" + "labels_mod = ['Chromap', 'bwa-mem2 + pairtools', 'bwa mem + pairtools', 'Juicer', 'Hi-Pro', 'HiCExplorer', 'bwa mem + FANC', 'bowtie2 + FANC']" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 54, "id": "8f31f3be-cf8f-4976-9a60-28e97c13593d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -984,6 +986,12 @@ "ax.set_ylabel('')\n", "ax.set_xlabel('Time (sec)')\n", "ax.set_yticklabels(labels_mod)\n", + "ax.set_axisbelow(True)\n", + "ax.grid(which='both', axis='x', color='k')\n", + "#ax.set_xscale('log')\n", + "ax.set_xlim([0, 5e3])\n", + "ax.set_xticks(np.arange(0, 5000, 100), minor=True)\n", + "ax.grid(which='minor', axis='x', alpha=0.2, color='k')\n", "ax.get_legend().remove()\n", "\n", "ax = axes[1]\n", @@ -999,6 +1007,10 @@ "ax.set_ylabel('')\n", "ax.set_xlabel('Maximum Resident Set Size (MB)')\n", "ax.set_yticklabels(labels_mod)\n", + "ax.set_axisbelow(True)\n", + "ax.grid(which='both', axis='x', color='k')\n", + "ax.set_xticks(np.arange(0, 30000, 1000), minor=True)\n", + "ax.grid(which='minor', axis='x', alpha=0.2, color='k')\n", "\n", "fig.suptitle('Benchmark of different Hi-C mapping tools for 1 mln reads (5 iterations)', y=0.99)\n", "\n", @@ -1009,6 +1021,84 @@ "plt.savefig(\"benchmarking_1mln.pdf\")" ] }, + { + "cell_type": "code", + "execution_count": 55, + "id": "1f41e7db-0f80-45f6-96f6-d1ae81055b83", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=1, ncols=2, sharey=True)\n", + "\n", + "cmap = ['#3E9ADE', '#EF242B', '#9FC741']\n", + "\n", + "style_dict = dict(\n", + " orient='h',\n", + " palette=cmap,\n", + " edgecolor=\"k\",\n", + " linewidth=2.0,\n", + " errwidth=2.0,\n", + " capsize=0.07)\n", + "\n", + "ax = axes[0]\n", + "sns.barplot(x=\"s\", \n", + " y=\"util\", \n", + " data=df.sort_values('util'),\n", + " order=labels,\n", + " hue='ncores',\n", + " hue_order=[4,2,1],\n", + " ax=ax,\n", + " **style_dict\n", + ")\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('Time (sec)')\n", + "ax.set_yticklabels(labels_mod)\n", + "ax.set_axisbelow(True)\n", + "ax.grid(which='both', axis='x', color='k')\n", + "ax.set_xscale('log')\n", + "ax.set_xlim([1, 5e3])\n", + "# ax.set_xticks(np.arange(0, 5000, 100), minor=True)\n", + "ax.grid(which='minor', axis='x', alpha=0.2, color='k')\n", + "ax.get_legend().remove()\n", + "\n", + "ax = axes[1]\n", + "sns.barplot(x=\"max_rss\", \n", + " y=\"util\", \n", + " data=df.sort_values('util'),\n", + " order=labels,\n", + " hue='ncores',\n", + " hue_order=[4,2,1],\n", + " ax=ax,\n", + " **style_dict)\n", + "\n", + "ax.set_ylabel('')\n", + "ax.set_xlabel('Maximum Resident Set Size (MB)')\n", + "ax.set_yticklabels(labels_mod)\n", + "ax.set_axisbelow(True)\n", + "ax.grid(which='both', axis='x', color='k')\n", + "ax.set_xticks(np.arange(0, 30000, 1000), minor=True)\n", + "ax.grid(which='minor', axis='x', alpha=0.2, color='k')\n", + "\n", + "fig.suptitle('Benchmark of different Hi-C mapping tools for 1 mln reads (5 iterations)', y=0.99)\n", + "\n", + "# (x, y, width, height)\n", + "bb = (fig.subplotpars.left, fig.subplotpars.top+0.002, fig.subplotpars.right-fig.subplotpars.left, 0.2)\n", + "ax.legend(bbox_to_anchor=bb, title=\"Number of cores\", loc=\"lower right\", ncol=3, borderaxespad=0., bbox_transform=fig.transFigure, frameon=False)\n", + "\n", + "plt.savefig(\"benchmarking_1mln_log.pdf\")" + ] + }, { "cell_type": "code", "execution_count": 10, From e20267fd7a07f4dda49dda65d713c731787ea2de Mon Sep 17 00:00:00 2001 From: Phlya Date: Thu, 19 May 2022 14:44:10 +0200 Subject: [PATCH 45/52] Fir dtype so it gets saved --- pairtools/lib/stats.py | 54 ++++++++++++++++++++++++++++-------------- 1 file changed, 36 insertions(+), 18 deletions(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 7ca266a0..f952589c 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -6,6 +6,7 @@ from . import fileio from .._logging import get_logger + logger = get_logger() @@ -25,7 +26,13 @@ class PairCounter(Mapping): _SEP = "\t" _KEY_SEP = "/" - def __init__(self, min_log10_dist=0, max_log10_dist=9, log10_dist_bin_step=0.25, bytile_dups=False): + def __init__( + self, + min_log10_dist=0, + max_log10_dist=9, + log10_dist_bin_step=0.25, + bytile_dups=False, + ): self._stat = {} # some variables used for initialization: # genomic distance bining for the ++/--/-+/+- distribution @@ -209,8 +216,11 @@ def calculate_summaries(self): if self._save_bytile_dups: # Estimate library complexity with information by tile, if provided: if self._bytile_dups.shape[0] > 0: - self._stat["dups_by_tile_median"] = ( - self._bytile_dups["dup_count"].median() * self._bytile_dups.shape[0] + self._stat["dups_by_tile_median"] = int( + round( + self._bytile_dups["dup_count"].median() + * self._bytile_dups.shape[0] + ) ) if "dups_by_tile_median" in self._stat.keys(): self._stat["summary"][ @@ -468,9 +478,9 @@ def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): ### Add by-tile dups if self._save_bytile_dups and (df_dups.shape[0] > 0): bytile_dups = analyse_bytile_duplicate_stats(df_dups) - self._bytile_dups = self._bytile_dups.add( - bytile_dups, fill_value=0 - ).astype(int) + self._bytile_dups = self._bytile_dups.add(bytile_dups, fill_value=0).astype( + int + ) def add_chromsizes(self, chromsizes): """ Add chromsizes field to the output stats @@ -581,9 +591,7 @@ def flatten(self): flat_stat[formatted_key] = freq elif (k == "summary") and v: for key, frac in v.items(): - formatted_key = self._KEY_SEP.join(["{}", "{}"]).format( - k, key - ) + formatted_key = self._KEY_SEP.join(["{}", "{}"]).format(k, key) # store key,value pair: flat_stat[formatted_key] = frac @@ -693,6 +701,7 @@ def save_bytile_dups(self, outstream): ################## # Other functions: + def do_merge(output, files_to_merge, **kwargs): # Parse all stats files. stats = [] @@ -725,6 +734,7 @@ def do_merge(output, files_to_merge, **kwargs): if outstream != sys.stdout: outstream.close() + def estimate_library_complexity(nseq, ndup, nopticaldup=0): """Estimate library complexity accounting for optical/clustering duplicates Parameters @@ -746,11 +756,13 @@ def estimate_library_complexity(nseq, ndup, nopticaldup=0): return 0 ndup = ndup - nopticaldup u = (nseq - ndup) / nseq - if u==0: - logger.warning("All the sequences are duplicates. Do you run complexity estimation on duplicates file?") + if u == 0: + logger.warning( + "All the sequences are duplicates. Do you run complexity estimation on duplicates file?" + ) return 0 seq_to_complexity = special.lambertw(-np.exp(-1 / u) / u).real + 1 / u - complexity = float(nseq / seq_to_complexity) # clean np.int64 data type + complexity = float(nseq / seq_to_complexity) # clean np.int64 data type return complexity @@ -771,9 +783,11 @@ def analyse_bytile_duplicate_stats(df_dups, tile_dup_regex=False): df_dups = df_dups.copy() df_dups["tile"] = extract_tile_info(df_dups["readID"], regex=tile_dup_regex) - df_dups["parent_tile"] = extract_tile_info(df_dups["parent_readID"], regex=tile_dup_regex) + df_dups["parent_tile"] = extract_tile_info( + df_dups["parent_readID"], regex=tile_dup_regex + ) - df_dups["same_tile"] = (df_dups["tile"] == df_dups["parent_tile"]) + df_dups["same_tile"] = df_dups["tile"] == df_dups["parent_tile"] bytile_dups = ( df_dups.groupby(["tile", "parent_tile"]) .size() @@ -805,12 +819,16 @@ def extract_tile_info(series, regex=False): """ if regex: split = series.str.extractall(regex).unstack().droplevel(1, axis=1) - if split.shape[1]<4: - raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") + if split.shape[1] < 4: + raise ValueError( + f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}" + ) return split[0] + ":" + split[1] + ":" + split[2] else: try: - split = [":".join(name.split(':')[2:5]) for name in series] + split = [":".join(name.split(":")[2:5]) for name in series] except: - raise ValueError(f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}") + raise ValueError( + f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}" + ) return split From 9a21e150d7ddc861cf9e722b2df01a713b4238f3 Mon Sep 17 00:00:00 2001 From: Ilya Flyamer Date: Fri, 20 May 2022 03:02:49 +0200 Subject: [PATCH 46/52] [WIP] Stats split by filters (#132) * Filtering stats * Multiple filters; save the filtering expression * distance bins saved, saving and reading yaml works * update test * select is now a separate library used by stats and select CLI * Python engine for stats filtering added * black stats and select * travis fix yaml Co-authored-by: Aleksandra Galitsyna --- .github/workflows/python-package.yml | 2 +- pairtools/cli/select.py | 83 ++--- pairtools/cli/stats.py | 90 ++++- pairtools/lib/__init__.py | 1 + pairtools/lib/select.py | 135 +++++++ pairtools/lib/stats.py | 520 ++++++++++++++------------- tests/test_stats.py | 86 +++-- 7 files changed, 565 insertions(+), 352 deletions(-) create mode 100644 pairtools/lib/select.py diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml index cb1e04f9..6c2ae211 100644 --- a/.github/workflows/python-package.yml +++ b/.github/workflows/python-package.yml @@ -48,7 +48,7 @@ jobs: conda info -a # Create test environment and install deps - conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy yaml bioframe + conda create -q -n test-environment python=${{ matrix.python-version }} setuptools pip cython numpy pandas nose samtools pysam scipy pyyaml bioframe source activate test-environment pip install click python setup.py build_ext -i diff --git a/pairtools/cli/select.py b/pairtools/cli/select.py index e0d5723d..72016d50 100644 --- a/pairtools/cli/select.py +++ b/pairtools/cli/select.py @@ -4,6 +4,7 @@ import warnings from ..lib import fileio, pairsam_format, headerops +from ..lib.select import evaluate_stream from . import cli, common_io_options UTIL_NAME = "pairtools_select" @@ -84,7 +85,7 @@ def select( startup_code, type_cast, remove_columns, - **kwargs + **kwargs, ): """Select pairs according to some condition. @@ -120,7 +121,7 @@ def select( pairtools select '(chrom1=="!") and (chrom2!="!")' pairtools select 'regex_match(chrom1, "chr\d+") and regex_match(chrom2, "chr\d+")' - pairtools select 'True' --chr-subset mm9.reduced.chromsizes + pairtools select 'True' --chrom-subset mm9.reduced.chromsizes """ select_py( @@ -132,7 +133,7 @@ def select( startup_code, type_cast, remove_columns, - **kwargs + **kwargs, ) @@ -145,7 +146,7 @@ def select_py( startup_code, type_cast, remove_columns, - **kwargs + **kwargs, ): instream = fileio.auto_open( @@ -171,38 +172,7 @@ def select_py( command=kwargs.get("cmd_out", None), ) - wildcard_library = {} - - def wildcard_match(x, wildcard): - if wildcard not in wildcard_library: - regex = fnmatch.translate(wildcard) - reobj = re.compile(regex) - wildcard_library[wildcard] = reobj - return wildcard_library[wildcard].fullmatch(x) - - csv_library = {} - - def csv_match(x, csv): - if csv not in csv_library: - csv_library[csv] = set(csv.split(",")) - return x in csv_library[csv] - - regex_library = {} - - def regex_match(x, regex): - if regex not in regex_library: - reobj = re.compile(regex) - regex_library[regex] = reobj - return regex_library[regex].fullmatch(x) - - new_chroms = None - if chrom_subset is not None: - new_chroms = [l.strip().split("\t")[0] for l in open(chrom_subset, "r")] - - TYPES = {"pos1": "int", "pos2": "int", "mapq1": "int", "mapq2": "int"} - - TYPES.update(dict(type_cast)) - + # Parse the input stream: header, body_stream = headerops.get_header(instream) # Modify the header: @@ -231,6 +201,10 @@ def regex_match(x, regex): header = headerops.set_columns(header, updated_columns) # Update the chromosomes: + new_chroms = None + if chrom_subset is not None: + new_chroms = [l.strip().split("\t")[0] for l in open(chrom_subset, "r")] + if new_chroms is not None: header = headerops.subset_chroms_in_pairsheader(header, new_chroms) outstream.writelines((l + "\n" for l in header)) @@ -241,36 +215,27 @@ def regex_match(x, regex): if len(column_names) == 0: column_names = pairsam_format.COLUMNS - if startup_code is not None: - exec(startup_code, globals()) + # Columns filtration rule: + if remove_columns: + column_scheme = [input_columns.index(COL) for COL in updated_columns] + # Format the condition: condition = condition.strip() if new_chroms is not None: condition = ( - "({}) and (chrom1 in new_chroms) " "and (chrom2 in new_chroms)" - ).format(condition) - - for i, col in enumerate(column_names): - if col in TYPES: - col_type = TYPES[col] - condition = condition.replace(col, "{}(COLS[{}])".format(col_type, i)) - else: - condition = condition.replace(col, "COLS[{}]".format(i)) - - # Compile the filtering expression: - match_func = compile(condition, "", "eval") - - # Columns filtration rule: - if remove_columns: - column_scheme = [input_columns.index(COL) for COL in updated_columns] + f"({condition}) and (chrom1 in {new_chroms}) and (chrom2 in {new_chroms})" + ) - for line in body_stream: + for filter_passed, line in evaluate_stream( + body_stream, condition, column_names, type_cast, startup_code + ): COLS = line.rstrip().split(pairsam_format.PAIRSAM_SEP) - # Evaluate filtering expression: - filter_passed = eval(match_func) + if remove_columns: - COLS = [COLS[idx] for idx in column_scheme] # re-order the columns according to the scheme: - line = pairsam_format.PAIRSAM_SEP.join(COLS)+'\n' # form the line + COLS = [ + COLS[idx] for idx in column_scheme + ] # re-order the columns according to the scheme: + line = pairsam_format.PAIRSAM_SEP.join(COLS) + "\n" # form the line if filter_passed: outstream.write(line) diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index 890988b0..7252106f 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -11,6 +11,7 @@ from ..lib.stats import PairCounter, do_merge from .._logging import get_logger + logger = get_logger() UTIL_NAME = "pairtools_stats" @@ -60,8 +61,56 @@ " By default, by-tile duplicate statistics are not printed." " Note that the readID and parent_readID should be provided and contain tile information for this option.", ) +# Filtering options: +@click.option( + "--filter", + default=None, + required=False, + multiple=True, + help="Filters with conditions to apply to the data (similar to `pairtools select`). " + "For non-YAML output only the first filter will be reported. " + """Example: pairtools stats --yaml --filter 'unique:(pair_type=="UU")' --filter 'close:(pair_type=="UU") and (abs(pos1-pos2)<10)' test.pairs """, +) +@click.option( + "--engine", + default="pandas", + required=False, + help="Engine for regular expression parsing. " + "Python will provide you regex functionality, while pandas does not accept custom funtctions and works faster. ", +) +@click.option( + "--chrom-subset", + type=str, + default=None, + required=False, + help="A path to a chromosomes file (tab-separated, 1st column contains " + "chromosome names) containing a chromosome subset of interest. " + "If provided, additionally filter pairs with both sides originating from " + "the provided subset of chromosomes. This operation modifies the #chromosomes: " + "and #chromsize: header fields accordingly.", +) +@click.option( + "--startup-code", + type=str, + default=None, + required=False, + help="An auxiliary code to execute before filtering. " + "Use to define functions that can be evaluated in the CONDITION statement", +) +@click.option( + "-t", + "--type-cast", + type=(str, str), + default=(), + multiple=True, + help="Cast a given column to a given type. By default, only pos and mapq " + "are cast to int, other columns are kept as str. Provide as " + "-t , e.g. -t read_len1 int. Multiple entries are allowed.", +) @common_io_options -def stats(input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs): +def stats( + input_path, output, merge, bytile_dups, output_bytile_stats, filter, **kwargs +): """Calculate pairs statistics. INPUT_PATH : by default, a .pairs/.pairsam file to calculate statistics. @@ -73,12 +122,18 @@ def stats(input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs) """ stats_py( - input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs, + input_path, + output, + merge, + bytile_dups, + output_bytile_stats, + filter, + **kwargs, ) def stats_py( - input_path, output, merge, bytile_dups, output_bytile_stats, **kwargs + input_path, output, merge, bytile_dups, output_bytile_stats, filter, **kwargs ): if merge: do_merge(output, input_path, **kwargs) @@ -114,8 +169,27 @@ def stats_py( ) bytile_dups = False + # Define filters and their properties + first_filter_name = "no_filter" # default filter name for full output + if filter is not None and len(filter) > 0: + first_filter_name = filter[0].split(":", 1)[0] + if len(filter) > 1 and not kwargs.get("yaml", False): + logger.warn( + f"Output the first filter only in non-YAML output: {first_filter_name}" + ) + + filter = dict([f.split(":", 1) for f in filter]) + else: + filter = None + # new stats class stuff would come here ... - stats = PairCounter(bytile_dups=bytile_dups) + stats = PairCounter( + bytile_dups=bytile_dups, + filters=filter, + startup_code=kwargs.get("startup_code", ""), # for evaluation of filters + type_cast=kwargs.get("type_cast", ()), # for evaluation of filters + engine=kwargs.get("engine", "pandas"), + ) # Collecting statistics for chunk in pd.read_table(body_stream, names=cols, chunksize=100_000): @@ -129,7 +203,13 @@ def stats_py( stats.save_bytile_dups(output_bytile_stats) # save statistics to file ... - stats.save(outstream, yaml=kwargs.get("yaml", False)) + stats.save( + outstream, + yaml=kwargs.get("yaml", False), # format as yaml + filter=first_filter_name + if not kwargs.get("yaml", False) + else None, # output only the first filter if non-YAML output + ) if instream != sys.stdin: instream.close() diff --git a/pairtools/lib/__init__.py b/pairtools/lib/__init__.py index b57ae2e9..2ba33529 100644 --- a/pairtools/lib/__init__.py +++ b/pairtools/lib/__init__.py @@ -9,3 +9,4 @@ from . import parse_pysam from . import restrict from . import stats +from . import select diff --git a/pairtools/lib/select.py b/pairtools/lib/select.py new file mode 100644 index 00000000..a5774679 --- /dev/null +++ b/pairtools/lib/select.py @@ -0,0 +1,135 @@ +from ..lib import fileio, pairsam_format, headerops +import re, fnmatch + +# Create environment of important functions: +wildcard_library = {} + + +def wildcard_match(x, wildcard): + if wildcard not in wildcard_library: + regex = fnmatch.translate(wildcard) + reobj = re.compile(regex) + wildcard_library[wildcard] = reobj + return wildcard_library[wildcard].fullmatch(x) + + +csv_library = {} + + +def csv_match(x, csv): + if csv not in csv_library: + csv_library[csv] = set(csv.split(",")) + return x in csv_library[csv] + + +regex_library = {} + + +def regex_match(x, regex): + if regex not in regex_library: + reobj = re.compile(regex) + regex_library[regex] = reobj + return regex_library[regex].fullmatch(x) + + +# Define default data types: +TYPES = {"pos1": "int", "pos2": "int", "mapq1": "int", "mapq2": "int"} + + +def evaluate_stream( + headerless_stream, condition, column_names, type_cast=(), startup_code=None +): + """ + Evaluate expression for the input headerless stream. + + Parameters + ---------- + headerless_stream + condition + type_cast: Cast a given column to a given type. By default, only pos and mapq + are cast to int, other columns are kept as str. Type: tupe of two strings. + startup_code: An auxiliary code to execute before filtering. + Use to define functions that can be evaluated in the CONDITION statement + + ======== + Writes the output to one of two streams (regular or rest) + + """ + + # Define data types: + TYPES.update(dict(type_cast)) + + # Execute startup code: + if startup_code is not None: + exec(startup_code, globals()) + + for i, col in enumerate(column_names): + if col in TYPES: + col_type = TYPES[col] + condition = condition.replace(col, "{}(COLS[{}])".format(col_type, i)) + else: + condition = condition.replace(col, "COLS[{}]".format(i)) + + # Compile the filtering expression: + match_func = compile(condition, "", "eval") + + for line in headerless_stream: + COLS = line.rstrip().split(pairsam_format.PAIRSAM_SEP) + + # Evaluate filtering expression: + filter_passed = eval(match_func) + + # Produce the output: + yield filter_passed, line + + +def evaluate_df(df, condition, type_cast=(), startup_code=None, engine="pandas"): + """ + Evaluate expression for the input headerless stream. + + Parameters + ---------- + df: input dataframe for evaluation + condition: condition to evaluate + type_cast: additional types transformations, if different from default + startup_code: An auxiliary code to execute before filtering. + Use to define functions that can be evaluated in the CONDITION statement + + ======== + Writes the output to one of two streams (regular or rest) + + """ + + # Define data types: + TYPES.update(dict(type_cast)) + + # Execute startup code: + if startup_code is not None: + exec(startup_code, globals()) + + # Set up the column formats: + for col in df.columns: + if col in TYPES.keys(): + if not str(df.dtypes[col]) != TYPES[col]: + df[col] = df[col].astype(TYPES[col]) + + if engine == "pandas": + try: + filter_passed_output = df.eval(condition) + except ValueError as e: + raise ValueError(f"Try passing engine python to fix this: {e}") + else: + # Set up the columns indexing + for i, col in enumerate(df.columns): + condition = condition.replace(col, "COLS[{}]".format(i)) + + filter_passed_output = [] + match_func = compile(condition, "", "eval") + for i, r in df.iterrows(): + COLS = r.values + + # Evaluate filtering expression: + filter_passed = eval(match_func) + filter_passed_output.append(True if filter_passed else False) + + return filter_passed_output diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index f952589c..4420ed0a 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -3,7 +3,9 @@ from scipy import special from collections.abc import Mapping import sys +import yaml from . import fileio +from .select import evaluate_df from .._logging import get_logger @@ -13,11 +15,9 @@ class PairCounter(Mapping): """ A Counter for Hi-C pairs that accumulates various statistics. - PairCounter implements two interfaces to access multi-level statistics: 1. as a nested dict, e.g. pairCounter['pair_types']['LL'] 2. as a flat dict, with the level keys separated by '/', e.g. pairCounter['pair_types/LL'] - Other features: -- PairCounters can be saved into/loaded from a file -- multiple PairCounters can be merged via addition. @@ -32,8 +32,23 @@ def __init__( max_log10_dist=9, log10_dist_bin_step=0.25, bytile_dups=False, + filters=None, + **kwargs, ): - self._stat = {} + # Define filters and parameters for filters evaluation: + if filters is not None: + self.filters = filters + else: + self.filters = {"no_filter": ""} + self.startup_code = kwargs.get("startup_code", "") + self.type_cast = kwargs.get("type_cast", ()) + self.engine = kwargs.get("engine", "pandas") + + # Define default filter: + if "no_filter" not in self.filters: + self.filters["no_filter"] = "" + self._stat = {key: {} for key in self.filters} + # some variables used for initialization: # genomic distance bining for the ++/--/-+/+- distribution self._dist_bins = np.r_[ @@ -47,52 +62,55 @@ def __init__( ] # establish structure of an empty _stat: - self._stat["total"] = 0 - self._stat["total_unmapped"] = 0 - self._stat["total_single_sided_mapped"] = 0 - # total_mapped = total_dups + total_nodups - self._stat["total_mapped"] = 0 - self._stat["total_dups"] = 0 - self._stat["total_nodups"] = 0 - ######################################## - # the rest of stats are based on nodups: - ######################################## - self._stat["cis"] = 0 - self._stat["trans"] = 0 - self._stat["pair_types"] = {} - # to be removed: - self._stat["dedup"] = {} - - self._stat["cis_1kb+"] = 0 - self._stat["cis_2kb+"] = 0 - self._stat["cis_4kb+"] = 0 - self._stat["cis_10kb+"] = 0 - self._stat["cis_20kb+"] = 0 - self._stat["cis_40kb+"] = 0 - - self._stat["chrom_freq"] = {} - - self._stat["dist_freq"] = { - "+-": np.zeros(len(self._dist_bins), dtype=np.int), - "-+": np.zeros(len(self._dist_bins), dtype=np.int), - "--": np.zeros(len(self._dist_bins), dtype=np.int), - "++": np.zeros(len(self._dist_bins), dtype=np.int), - } - - # Summaries are derived from other stats and are recalculated on merge - self._stat["summary"] = dict( - [ - ("frac_cis", 0), - ("frac_cis_1kb+", 0), - ("frac_cis_2kb+", 0), - ("frac_cis_4kb+", 0), - ("frac_cis_10kb+", 0), - ("frac_cis_20kb+", 0), - ("frac_cis_40kb+", 0), - ("frac_dups", 0), - ("complexity_naive", 0), - ] - ) + for key in self.filters: + self._stat[key]["filter_expression"] = self.filters[key] + self._stat[key]["total"] = 0 + self._stat[key]["total_unmapped"] = 0 + self._stat[key]["total_single_sided_mapped"] = 0 + # total_mapped = total_dups + total_nodups + self._stat[key]["total_mapped"] = 0 + self._stat[key]["total_dups"] = 0 + self._stat[key]["total_nodups"] = 0 + ######################################## + # the rest of stats are based on nodups: + ######################################## + self._stat[key]["cis"] = 0 + self._stat[key]["trans"] = 0 + self._stat[key]["pair_types"] = {} + # to be removed: + self._stat[key]["dedup"] = {} + + self._stat[key]["cis_1kb+"] = 0 + self._stat[key]["cis_2kb+"] = 0 + self._stat[key]["cis_4kb+"] = 0 + self._stat[key]["cis_10kb+"] = 0 + self._stat[key]["cis_20kb+"] = 0 + self._stat[key]["cis_40kb+"] = 0 + self._stat[key]["summary"] = dict( + [ + ("frac_cis", 0), + ("frac_cis_1kb+", 0), + ("frac_cis_2kb+", 0), + ("frac_cis_4kb+", 0), + ("frac_cis_10kb+", 0), + ("frac_cis_20kb+", 0), + ("frac_cis_40kb+", 0), + ("frac_dups", 0), + ("complexity_naive", 0), + ] + ) + + self._stat[key]["chrom_freq"] = {} + + self._stat[key]["dist_freq"] = { + "+-": {bin.item(): 0 for bin in self._dist_bins}, + "-+": {bin.item(): 0 for bin in self._dist_bins}, + "--": {bin.item(): 0 for bin in self._dist_bins}, + "++": {bin.item(): 0 for bin in self._dist_bins}, + } + + # Summaries are derived from other stats and are recalculated on merge + self._save_bytile_dups = bytile_dups if self._save_bytile_dups: self._bytile_dups = pd.DataFrame( @@ -185,53 +203,52 @@ def __len__(self): def calculate_summaries(self): """calculate summary statistics (fraction of cis pairs at different cutoffs, complexity estimate) based on accumulated counts. Results are saved into - self._stat['summary'] + self._stat["filter_name"]['summary"] """ - - self._stat["summary"]["frac_dups"] = ( - (self._stat["total_dups"] / self._stat["total_mapped"]) - if self._stat["total_mapped"] > 0 - else 0 - ) - - for cis_count in ( - "cis", - "cis_1kb+", - "cis_2kb+", - "cis_4kb+", - "cis_10kb+", - "cis_20kb+", - "cis_40kb+", - ): - self._stat["summary"][f"frac_{cis_count}"] = ( - (self._stat[cis_count] / self._stat["total_nodups"]) - if self._stat["total_nodups"] > 0 + for key in self.filters.keys(): + self._stat[key]["summary"]["frac_dups"] = ( + (self._stat[key]["total_dups"] / self._stat[key]["total_mapped"]) + if self._stat[key]["total_mapped"] > 0 else 0 ) - self._stat["summary"]["complexity_naive"] = estimate_library_complexity( - self._stat["total_mapped"], self._stat["total_dups"], 0 - ) + for cis_count in ( + "cis", + "cis_1kb+", + "cis_2kb+", + "cis_4kb+", + "cis_10kb+", + "cis_20kb+", + "cis_40kb+", + ): + self._stat[key]["summary"][f"frac_{cis_count}"] = ( + (self._stat[key][cis_count] / self._stat[key]["total_nodups"]) + if self._stat[key]["total_nodups"] > 0 + else 0 + ) - if self._save_bytile_dups: - # Estimate library complexity with information by tile, if provided: - if self._bytile_dups.shape[0] > 0: - self._stat["dups_by_tile_median"] = int( - round( + self._stat[key]["summary"][ + "complexity_naive" + ] = estimate_library_complexity( + self._stat[key]["total_mapped"], self._stat[key]["total_dups"], 0 + ) + if key == "no_filter" and self._save_bytile_dups: + # Estimate library complexity with information by tile, if provided: + if self._bytile_dups.shape[0] > 0: + self._stat[key]["dups_by_tile_median"] = ( self._bytile_dups["dup_count"].median() * self._bytile_dups.shape[0] ) - ) - if "dups_by_tile_median" in self._stat.keys(): - self._stat["summary"][ - "complexity_dups_by_tile_median" - ] = estimate_library_complexity( - self._stat["total_mapped"], - self._stat["total_dups"], - self._stat["dups_by_tile_median"], - ) + if "dups_by_tile_median" in self._stat[key].keys(): + self._stat[key]["summary"][ + "complexity_dups_by_tile_median" + ] = estimate_library_complexity( + self._stat[key]["total_mapped"], + self._stat[key]["total_dups"], + self._stat[key]["dups_by_tile_median"], + ) - self._summaries_calculated = True + self._summaries_calculated = True @classmethod def from_file(cls, file_handle): @@ -337,9 +354,33 @@ def from_file(cls, file_handle): # return PairCounter from a non-empty dict: return stat_from_file + @classmethod + def from_yaml(cls, file_handle): + """create instance of PairCounter from file + Parameters + ---------- + file_handle: file handle + Returns + ------- + PairCounter + new PairCounter filled with the contents of the input file + """ + # fill in from file - file_handle: + stat_from_file = cls() + + stat = yaml.safe_load(file_handle) + for key, filter in stat.items(): + chromdict = {} + for chroms in stat[key]["chrom_freq"].keys(): + chromdict[tuple(chroms.split(cls._KEY_SEP))] = stat[key]["chrom_freq"][ + chroms + ] + stat[key]["chrom_freq"] = chromdict + stat_from_file._stat = stat + return stat_from_file + def add_pair(self, chrom1, pos1, strand1, chrom2, pos2, strand2, pair_type): """Gather statistics for a Hi-C pair and add to the PairCounter. - Parameters ---------- chrom1: str @@ -358,133 +399,155 @@ def add_pair(self, chrom1, pos1, strand1, chrom2, pos2, strand2, pair_type): type of the mapped pair of reads """ - self._stat["total"] += 1 + self._stat["no_filter"]["total"] += 1 # collect pair type stats including DD: - self._stat["pair_types"][pair_type] = ( - self._stat["pair_types"].get(pair_type, 0) + 1 + self._stat["no_filter"]["pair_types"][pair_type] = ( + self._stat["no_filter"]["pair_types"].get(pair_type, 0) + 1 ) if chrom1 == "!" and chrom2 == "!": - self._stat["total_unmapped"] += 1 + self._stat["no_filter"]["total_unmapped"] += 1 elif chrom1 != "!" and chrom2 != "!": - self._stat["total_mapped"] += 1 + self._stat["no_filter"]["total_mapped"] += 1 # only mapped ones can be duplicates: if pair_type == "DD": - self._stat["total_dups"] += 1 + self._stat["no_filter"]["total_dups"] += 1 else: - self._stat["total_nodups"] += 1 - self._stat["chrom_freq"][(chrom1, chrom2)] = ( - self._stat["chrom_freq"].get((chrom1, chrom2), 0) + 1 + self._stat["no_filter"]["total_nodups"] += 1 + self._stat["no_filter"]["chrom_freq"][(chrom1, chrom2)] = ( + self._stat["no_filter"]["chrom_freq"].get((chrom1, chrom2), 0) + 1 ) if chrom1 == chrom2: - self._stat["cis"] += 1 + self._stat["no_filter"]["cis"] += 1 dist = np.abs(pos2 - pos1) - bin_idx = np.searchsorted(self._dist_bins, dist, "right") - 1 - self._stat["dist_freq"][strand1 + strand2][bin_idx] += 1 + bin = self._dist_bins[ + np.searchsorted(self._dist_bins, dist, "right") - 1 + ] + self._stat["no_filter"]["dist_freq"][strand1 + strand2][bin] += 1 if dist >= 1000: - self._stat["cis_1kb+"] += 1 + self._stat["no_filter"]["cis_1kb+"] += 1 if dist >= 2000: - self._stat["cis_2kb+"] += 1 + self._stat["no_filter"]["cis_2kb+"] += 1 if dist >= 4000: - self._stat["cis_4kb+"] += 1 + self._stat["no_filter"]["cis_4kb+"] += 1 if dist >= 10000: - self._stat["cis_10kb+"] += 1 + self._stat["no_filter"]["cis_10kb+"] += 1 if dist >= 20000: - self._stat["cis_20kb+"] += 1 + self._stat["no_filter"]["cis_20kb+"] += 1 if dist >= 40000: - self._stat["cis_40kb+"] += 1 + self._stat["no_filter"]["cis_40kb+"] += 1 else: - self._stat["trans"] += 1 + self._stat["no_filter"]["trans"] += 1 else: - self._stat["total_single_sided_mapped"] += 1 + self._stat["no_filter"]["total_single_sided_mapped"] += 1 def add_pairs_from_dataframe(self, df, unmapped_chrom="!"): """Gather statistics for Hi-C pairs in a dataframe and add to the PairCounter. - + Parameters ---------- df: pd.DataFrame DataFrame with pairs. Needs to have columns: 'chrom1', 'pos1', 'chrom2', 'pos2', 'strand1', 'strand2', 'pair_type' """ + for key in self.filters.keys(): + if key == "no_filter": + df_filtered = df.copy() + else: + condition = self.filters[key] + filter_passed = evaluate_df( + df, + condition, + type_cast=self.type_cast, + startup_code=self.startup_code, + engine=self.engine, + ) + df_filtered = df.loc[filter_passed, :].reset_index(drop=True) + total_count = df_filtered.shape[0] + self._stat[key]["total"] += total_count + + # collect pair type stats including DD: + for pair_type, type_count in ( + df_filtered["pair_type"].value_counts().items() + ): + self._stat[key]["pair_types"][pair_type] = ( + self._stat[key]["pair_types"].get(pair_type, 0) + type_count + ) - total_count = df.shape[0] - self._stat["total"] += total_count + # Count the unmapped by the "unmapped" chromosomes (debatable, as WW are also marked as ! and they might be mapped): + unmapped_count = np.logical_and( + df_filtered["chrom1"] == unmapped_chrom, + df_filtered["chrom2"] == unmapped_chrom, + ).sum() + self._stat[key]["total_unmapped"] += int(unmapped_count) + + # Count the mapped: + df_mapped = df_filtered.loc[ + (df_filtered["chrom1"] != unmapped_chrom) + & (df_filtered["chrom2"] != unmapped_chrom), + :, + ] + mapped_count = df_mapped.shape[0] - # collect pair type stats including DD: - for pair_type, type_count in df["pair_type"].value_counts().items(): - self._stat["pair_types"][pair_type] = ( - self._stat["pair_types"].get(pair_type, 0) + type_count + self._stat[key]["total_mapped"] += mapped_count + self._stat[key]["total_single_sided_mapped"] += int( + total_count - (mapped_count + unmapped_count) ) - # Count the unmapped by the "unmapped" chromosomes (debatable, as WW are also marked as ! and they might be mapped): - unmapped_count = np.logical_and( - df["chrom1"] == unmapped_chrom, df["chrom2"] == unmapped_chrom - ).sum() - self._stat["total_unmapped"] += int(unmapped_count) - - # Count the mapped: - df_mapped = df.loc[ - (df["chrom1"] != unmapped_chrom) & (df["chrom2"] != unmapped_chrom), : - ] - mapped_count = df_mapped.shape[0] + # Count the duplicates: + if "duplicate" in df_mapped.columns: + mask_dups = df_mapped["duplicate"] + else: + mask_dups = df_mapped["pair_type"] == "DD" + df_dups = df_mapped[mask_dups] + dups_count = df_dups.shape[0] + self._stat[key]["total_dups"] += int(dups_count) + self._stat[key]["total_nodups"] += int(mapped_count - dups_count) + + df_nodups = df_mapped.loc[~mask_dups, :] + mask_cis = df_nodups["chrom1"] == df_nodups["chrom2"] + df_cis = df_nodups.loc[mask_cis, :].copy() + + # Count pairs per chromosome: + for (chrom1, chrom2), chrom_count in ( + df_nodups[["chrom1", "chrom2"]].value_counts().items() + ): + self._stat[key]["chrom_freq"][(chrom1, chrom2)] = ( + self._stat[key]["chrom_freq"].get((chrom1, chrom2), 0) + chrom_count + ) - self._stat["total_mapped"] += mapped_count - self._stat["total_single_sided_mapped"] += int( - total_count - (mapped_count + unmapped_count) - ) + # Count cis-trans by pairs: - # Count the duplicates: - if "duplicate" in df_mapped.columns: - mask_dups = df_mapped["duplicate"] - else: - mask_dups = df_mapped["pair_type"] == "DD" - df_dups = df_mapped[mask_dups] - dups_count = df_dups.shape[0] - self._stat["total_dups"] += int(dups_count) - self._stat["total_nodups"] += int(mapped_count - dups_count) - - df_nodups = df_mapped.loc[~mask_dups, :] - mask_cis = df_nodups["chrom1"] == df_nodups["chrom2"] - df_cis = df_nodups.loc[mask_cis, :].copy() - - # Count pairs per chromosome: - for (chrom1, chrom2), chrom_count in ( - df_nodups[["chrom1", "chrom2"]].value_counts().items() - ): - self._stat["chrom_freq"][(chrom1, chrom2)] = ( - self._stat["chrom_freq"].get((chrom1, chrom2), 0) + chrom_count - ) + self._stat[key]["cis"] += df_cis.shape[0] + self._stat[key]["trans"] += df_nodups.shape[0] - df_cis.shape[0] + dist = np.abs(df_cis["pos2"].values - df_cis["pos1"].values) - # Count cis-trans by pairs: - - self._stat["cis"] += df_cis.shape[0] - self._stat["trans"] += df_nodups.shape[0] - df_cis.shape[0] - dist = np.abs(df_cis["pos2"].values - df_cis["pos1"].values) - - df_cis.loc[:, "bin_idx"] = np.searchsorted(self._dist_bins, dist, "right") - 1 - for (strand1, strand2, bin_id), strand_bin_count in ( - df_cis[["strand1", "strand2", "bin_idx"]].value_counts().items() - ): - self._stat["dist_freq"][strand1 + strand2][bin_id] += strand_bin_count - self._stat["cis_1kb+"] += int(np.sum(dist >= 1000)) - self._stat["cis_2kb+"] += int(np.sum(dist >= 2000)) - self._stat["cis_4kb+"] += int(np.sum(dist >= 4000)) - self._stat["cis_10kb+"] += int(np.sum(dist >= 10000)) - self._stat["cis_20kb+"] += int(np.sum(dist >= 20000)) - self._stat["cis_40kb+"] += int(np.sum(dist >= 40000)) - - ### Add by-tile dups - if self._save_bytile_dups and (df_dups.shape[0] > 0): - bytile_dups = analyse_bytile_duplicate_stats(df_dups) - self._bytile_dups = self._bytile_dups.add(bytile_dups, fill_value=0).astype( - int + df_cis.loc[:, "bin_idx"] = ( + np.searchsorted(self._dist_bins, dist, "right") - 1 ) + for (strand1, strand2, bin_id), strand_bin_count in ( + df_cis[["strand1", "strand2", "bin_idx"]].value_counts().items() + ): + self._stat[key]["dist_freq"][strand1 + strand2][ + self._dist_bins[bin_id].item() + ] += strand_bin_count + self._stat[key]["cis_1kb+"] += int(np.sum(dist >= 1000)) + self._stat[key]["cis_2kb+"] += int(np.sum(dist >= 2000)) + self._stat[key]["cis_4kb+"] += int(np.sum(dist >= 4000)) + self._stat[key]["cis_10kb+"] += int(np.sum(dist >= 10000)) + self._stat[key]["cis_20kb+"] += int(np.sum(dist >= 20000)) + self._stat[key]["cis_40kb+"] += int(np.sum(dist >= 40000)) + + ### Add by-tile dups + if key == "no_filter" and self._save_bytile_dups and (df_dups.shape[0] > 0): + bytile_dups = analyse_bytile_duplicate_stats(df_dups) + self._bytile_dups = self._bytile_dups.add( + bytile_dups, fill_value=0 + ).astype(int) def add_chromsizes(self, chromsizes): - """ Add chromsizes field to the output stats - + """Add chromsizes field to the output stats Parameters ---------- chromsizes: Dataframe with chromsizes, read by headerops.chromsizes @@ -545,13 +608,13 @@ def __radd__(self, other): else: return self.__add__(other) - def flatten(self): + def flatten(self, filter="no_filter"): """return a flattened dict (formatted same way as .stats file)""" # dict for flat store: flat_stat = {} # Storing statistics - for k, v in self._stat.items(): + for k, v in self._stat[filter].items(): if isinstance(v, int): flat_stat[k] = v # store nested dicts/arrays in a context dependet manner: @@ -562,17 +625,17 @@ def flatten(self): for dirs, freqs in v.items(): # last bin is treated differently: "100000+" vs "1200-3000": if i != len(self._dist_bins) - 1: + dist = self._dist_bins[i] + dist_next = self._dist_bins[i + 1] formatted_key = self._KEY_SEP.join( ["{}", "{}-{}", "{}"] - ).format( - k, self._dist_bins[i], self._dist_bins[i + 1], dirs - ) + ).format(k, dist, dist_next, dirs) else: formatted_key = self._KEY_SEP.join( ["{}", "{}+", "{}"] - ).format(k, self._dist_bins[i], dirs) + ).format(k, dist, dirs) # store key,value pair: - flat_stat[formatted_key] = freqs[i] + flat_stat[formatted_key] = freqs[dist] elif (k in ["pair_types", "dedup", "chromsizes"]) and v: # 'pair_types' and 'dedup' are simple dicts inside, # treat them the exact same way: @@ -598,77 +661,50 @@ def flatten(self): # return flattened dict return flat_stat - def format(self): + def format_yaml(self): """return a formatted dict (for the yaml output)""" from copy import deepcopy - formatted_stat = {} + formatted_stat = {key: {} for key in self.filters.keys()} - # Storing statistics - for k, v in self._stat.items(): - if isinstance(v, int): - formatted_stat[k] = v - # store nested dicts/arrays in a context dependet manner: - # nested categories are stored only if they are non-trivial - else: - if (k == "dist_freq") and v: - freqs_dct = {} - - # iterate over distance bins: - for i in range(len(self._dist_bins)): - # iterate over all directions: - for dirs, freqs in v.items(): - # last bin is treated differently: "100000+" vs "1200-3000": - if i != len(self._dist_bins) - 1: - dist = "{}-{}".format( - self._dist_bins[i], self._dist_bins[i + 1] - ) - else: - dist = "{}+".format(self._dist_bins[i]) - if dist not in freqs_dct.keys(): - freqs_dct[dist] = {} - - freqs_dct[dist][dirs] = int(freqs[i]) - - formatted_stat[k] = deepcopy(freqs_dct) - - elif (k in ["pair_types", "dedup", "chromsizes"]) and v: - # 'pair_types' and 'dedup' are simple dicts inside, - # treat them the exact same way: - formatted_stat[k] = deepcopy(v) - elif (k == "chrom_freq") and v: - freqs = {} - for (chrom1, chrom2), freq in v.items(): - freqs[ - self._KEY_SEP.join(["{}", "{}"]).format(chrom1, chrom2) - ] = freq - # store key,value pair: - formatted_stat[k] = deepcopy(freqs) - elif (k == "summary") and v: - summary_stats = {} - for key, frac in v.items(): - summary_stats[key] = frac - formatted_stat[k] = deepcopy(summary_stats) - - # return formatted dict + # Storing statistics for each filter + for key in self.filters.keys(): + for k, v in self._stat[key].items(): + if isinstance(v, int): + formatted_stat[key][k] = v + # store nested dicts/arrays in a context dependet manner: + # nested categories are stored only if they are non-trivial + else: + if (k != "chrom_freq") and v: + # simple dicts inside + # treat them the exact same way: + formatted_stat[key][k] = deepcopy(v) + elif (k == "chrom_freq") and v: + # need to convert tuples of chromosome names to str + freqs = {} + for (chrom1, chrom2), freq in sorted(v.items()): + freqs[ + self._KEY_SEP.join(["{}", "{}"]).format(chrom1, chrom2) + ] = freq + # store key,value pair: + formatted_stat[key][k] = deepcopy(freqs) + # return formatted dict return formatted_stat - def save(self, outstream, yaml=False): + def save(self, outstream, yaml=True, filter="no_filter"): """save PairCounter to tab-delimited text file. Flattened version of PairCounter is stored in the file. - Parameters ---------- outstream: file handle yaml: is output in yaml format or table - + filter: filter to output in tsv mode Note ---- The order of the keys is not guaranteed Merging several .stats is not associative with respect to key order: merge(A,merge(B,C)) != merge(merge(A,B),C). - Theys shou5ld match exactly, however, when soprted: sort(merge(A,merge(B,C))) == sort(merge(merge(A,B),C)) """ @@ -676,14 +712,16 @@ def save(self, outstream, yaml=False): if not self._summaries_calculated: self.calculate_summaries() - # write flattened version of the PairCounter to outstream + # write flattened version of the PairCounter to outstream, + # will output all the filters if yaml: import yaml - data = self.format() - yaml.dump(data, outstream, default_flow_style=False) - else: - for k, v in self.flatten().items(): + data = self.format_yaml() + yaml.dump(data, outstream, default_flow_style=False, sort_keys=False) + else: # will output a single filter + data = self.flatten(filter=filter) + for k, v in data.items(): outstream.write("{}{}{}\n".format(k, self._SEP, v)) def save_bytile_dups(self, outstream): diff --git a/tests/test_stats.py b/tests/test_stats.py index d3d6c985..182323f7 100644 --- a/tests/test_stats.py +++ b/tests/test_stats.py @@ -4,6 +4,8 @@ import subprocess from nose.tools import assert_raises import numpy as np +from pairtools.lib import stats +import yaml testdir = os.path.dirname(os.path.realpath(__file__)) @@ -12,58 +14,50 @@ def test_mock_pairsam(): mock_pairsam_path = os.path.join(testdir, "data", "mock.4stats.pairs") try: result = subprocess.check_output( - ["python", "-m", "pairtools", "stats", mock_pairsam_path], + ["python", "-m", "pairtools", "stats", "--yaml", mock_pairsam_path], ).decode("ascii") except subprocess.CalledProcessError as e: print(e.output) print(sys.exc_info()) raise e - stats = dict( - l.strip().split("\t") - for l in result.split("\n") - if not l.startswith("#") and l.strip() - ) + stats = yaml.safe_load(result) - for k in stats: - try: - stats[k] = int(stats[k]) - except ValueError: - stats[k] = float(stats[k]) + # for k in stats["no_filter"]: + # try: + # stats["no_filter"][k] = int(stats["no_filter"][k]) + # except (ValueError, TypeError): + # stats["no_filter"][k] = float(stats["no_filter"][k]) print(stats) - assert stats["total"] == 9 - assert stats["total_single_sided_mapped"] == 2 - assert stats["total_mapped"] == 6 - assert stats["total_dups"] == 1 - assert stats["cis"] == 3 - assert stats["trans"] == 2 - assert stats["pair_types/UU"] == 4 - assert stats["pair_types/NU"] == 1 - assert stats["pair_types/WW"] == 1 - assert stats["pair_types/UR"] == 1 - assert stats["pair_types/MU"] == 1 - assert stats["pair_types/DD"] == 1 - assert stats["chrom_freq/chr1/chr2"] == 1 - assert stats["chrom_freq/chr1/chr1"] == 3 - assert stats["chrom_freq/chr2/chr3"] == 1 - assert all( - stats[k] == 0 - for k in stats - if k.startswith("dist_freq") - and k not in ["dist_freq/1-2/++", "dist_freq/2-3/++", "dist_freq/32-56/++"] - ) - assert stats["dist_freq/1-2/++"] == 1 - assert stats["dist_freq/2-3/++"] == 1 - assert stats["dist_freq/32-56/++"] == 1 - assert stats["summary/frac_cis"] == 0.6 - assert stats["summary/frac_cis_1kb+"] == 0 - assert stats["summary/frac_cis_2kb+"] == 0 - assert stats["summary/frac_cis_4kb+"] == 0 - assert stats["summary/frac_cis_10kb+"] == 0 - assert stats["summary/frac_cis_20kb+"] == 0 - assert stats["summary/frac_cis_40kb+"] == 0 - assert np.isclose(stats["summary/frac_dups"], 1 / 6) - assert stats["dist_freq/1-2/++"] == 1 - assert stats["dist_freq/2-3/++"] == 1 - assert stats["dist_freq/32-56/++"] == 1 + assert stats["no_filter"]["total"] == 9 + assert stats["no_filter"]["total_single_sided_mapped"] == 2 + assert stats["no_filter"]["total_mapped"] == 6 + assert stats["no_filter"]["total_dups"] == 1 + assert stats["no_filter"]["cis"] == 3 + assert stats["no_filter"]["trans"] == 2 + assert stats["no_filter"]["pair_types"]["UU"] == 4 + assert stats["no_filter"]["pair_types"]["NU"] == 1 + assert stats["no_filter"]["pair_types"]["WW"] == 1 + assert stats["no_filter"]["pair_types"]["UR"] == 1 + assert stats["no_filter"]["pair_types"]["MU"] == 1 + assert stats["no_filter"]["pair_types"]["DD"] == 1 + assert stats["no_filter"]["chrom_freq"]["chr1/chr2"] == 1 + assert stats["no_filter"]["chrom_freq"]["chr1/chr1"] == 3 + assert stats["no_filter"]["chrom_freq"]["chr2/chr3"] == 1 + for orientation in ("++", "+-", "-+", "--"): + s = stats["no_filter"]["dist_freq"][orientation] + for k, val in s.items(): + if orientation == "++" and k in [1, 2, 32]: + assert s[k] == 1 + else: + assert s[k] == 0 + + assert stats["no_filter"]["summary"]["frac_cis"] == 0.6 + assert stats["no_filter"]["summary"]["frac_cis_1kb+"] == 0 + assert stats["no_filter"]["summary"]["frac_cis_2kb+"] == 0 + assert stats["no_filter"]["summary"]["frac_cis_4kb+"] == 0 + assert stats["no_filter"]["summary"]["frac_cis_10kb+"] == 0 + assert stats["no_filter"]["summary"]["frac_cis_20kb+"] == 0 + assert stats["no_filter"]["summary"]["frac_cis_40kb+"] == 0 + assert np.isclose(stats["no_filter"]["summary"]["frac_dups"], 1 / 6) From dabf4b7486d84f35e1f1b3c5a231edbfd9a9a44d Mon Sep 17 00:00:00 2001 From: Phlya Date: Fri, 20 May 2022 10:28:36 +0200 Subject: [PATCH 47/52] Fix bug in complexity estimation --- pairtools/lib/stats.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 4420ed0a..ef1cc803 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -245,7 +245,8 @@ def calculate_summaries(self): ] = estimate_library_complexity( self._stat[key]["total_mapped"], self._stat[key]["total_dups"], - self._stat[key]["dups_by_tile_median"], + self._stat[key]["total_dups"] + - self._stat[key]["dups_by_tile_median"], ) self._summaries_calculated = True From b08e8cdd911332165a8bdaf1bd7636fb7451b377 Mon Sep 17 00:00:00 2001 From: Phlya Date: Fri, 20 May 2022 14:31:00 +0200 Subject: [PATCH 48/52] Add yaml2pandas function --- pairtools/lib/stats.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index ef1cc803..4cca2295 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -871,3 +871,28 @@ def extract_tile_info(series, regex=False): f"Unable to convert tile names, does your readID have the tile information?\nHint: SRA removes tile information from readID.\nSample of your readIDs:\n{series.head()}" ) return split + + def yaml2pandas(yaml_path): + """Generate a pandas DataFrame with stats from a yaml file + + Formats the keys within each filter using the PairCounter.flatten() method, to + achieve same naming as in non-yaml stats files. + + Parameters + ---------- + yaml_path : str + Path to a yaml-formatted file with stats + + Returns + ------- + pd.DataFrame + Dataframe with filter names in the index and stats in columns + """ + counter = PairCounter.from_yaml(open(yaml_path, "r")) + stats = pd.concat( + [ + pd.DataFrame(counter.flatten(filter=filter), index=[filter]) + for filter in counter.filters + ] + ) + return stats From 68ec83afe3a6487fc8a37b853acd10f2902f2035 Mon Sep 17 00:00:00 2001 From: Phlya Date: Fri, 20 May 2022 16:46:15 +0200 Subject: [PATCH 49/52] Make by tile dups int --- pairtools/lib/stats.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/pairtools/lib/stats.py b/pairtools/lib/stats.py index 4cca2295..f723c694 100644 --- a/pairtools/lib/stats.py +++ b/pairtools/lib/stats.py @@ -235,9 +235,11 @@ def calculate_summaries(self): if key == "no_filter" and self._save_bytile_dups: # Estimate library complexity with information by tile, if provided: if self._bytile_dups.shape[0] > 0: - self._stat[key]["dups_by_tile_median"] = ( - self._bytile_dups["dup_count"].median() - * self._bytile_dups.shape[0] + self._stat[key]["dups_by_tile_median"] = int( + round( + self._bytile_dups["dup_count"].median() + * self._bytile_dups.shape[0] + ) ) if "dups_by_tile_median" in self._stat[key].keys(): self._stat[key]["summary"][ From 7647057193a632f2a1e1156d9a56c543e408acfd Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 31 May 2022 18:35:07 -0400 Subject: [PATCH 50/52] Markasdup lib removed; markasdup CLI explanation improved --- pairtools/cli/markasdup.py | 4 ++-- pairtools/lib/__init__.py | 1 - pairtools/lib/dedup.py | 41 +++++++++++++++++++++++++++++++++++- pairtools/lib/filterbycov.py | 4 ++-- pairtools/lib/markasdup.py | 40 ----------------------------------- 5 files changed, 44 insertions(+), 46 deletions(-) delete mode 100644 pairtools/lib/markasdup.py diff --git a/pairtools/cli/markasdup.py b/pairtools/cli/markasdup.py index b0f1cea8..fb351266 100644 --- a/pairtools/cli/markasdup.py +++ b/pairtools/cli/markasdup.py @@ -6,7 +6,7 @@ from ..lib import fileio, pairsam_format, headerops from . import cli, common_io_options -from ..lib.markasdup import mark_split_pair_as_dup +from ..lib.dedup import mark_split_pair_as_dup UTIL_NAME = "pairtools_markasdup" @@ -25,7 +25,7 @@ ) @common_io_options def markasdup(pairsam_path, output, **kwargs): - """Tag pairs as duplicates. + """Tag all pairs in the input file as duplicates. Change the type of all pairs inside a .pairs/.pairsam file to DD. If sam entries are present, change the pair type in the Yt SAM tag to 'Yt:Z:DD'. diff --git a/pairtools/lib/__init__.py b/pairtools/lib/__init__.py index 2ba33529..18f3b848 100644 --- a/pairtools/lib/__init__.py +++ b/pairtools/lib/__init__.py @@ -3,7 +3,6 @@ from . import dedup_cython from . import filterbycov from . import headerops -from . import markasdup from . import pairsam_format from . import parse from . import parse_pysam diff --git a/pairtools/lib/dedup.py b/pairtools/lib/dedup.py index a7aac0a9..53aaf8d3 100644 --- a/pairtools/lib/dedup.py +++ b/pairtools/lib/dedup.py @@ -6,7 +6,6 @@ from scipy.sparse.csgraph import connected_components from . import dedup_cython, pairsam_format -from .markasdup import mark_split_pair_as_dup from .stats import PairCounter from .._logging import get_logger @@ -545,3 +544,43 @@ def fetchadd(key, mydict): def ar(mylist, val): return np.array(mylist, dtype={8: np.int8, 16: np.int16, 32: np.int32}[val]) + + +#### Markasdup utilities: #### +def mark_split_pair_as_dup(cols): + # if the original columns ended with a new line, the marked columns + # should as well. + original_has_newline = cols[-1].endswith("\n") + + cols[pairsam_format.COL_PTYPE] = "DD" + + if (len(cols) > pairsam_format.COL_SAM1) and (len(cols) > pairsam_format.COL_SAM2): + for i in (pairsam_format.COL_SAM1, pairsam_format.COL_SAM2): + + # split each sam column into sam entries, tag and assemble back + cols[i] = pairsam_format.INTER_SAM_SEP.join( + [ + mark_sam_as_dup(sam) + for sam in cols[i].split(pairsam_format.INTER_SAM_SEP) + ] + ) + + if original_has_newline and not cols[-1].endswith("\n"): + cols[-1] = cols[-1] + "\n" + return cols + + +def mark_sam_as_dup(sam): + """Tag the binary flag and the optional pair type field of a sam entry + as a PCR duplicate.""" + samcols = sam.split(pairsam_format.SAM_SEP) + + if len(samcols) == 1: + return sam + + samcols[1] = str(int(samcols[1]) | 1024) + + for j in range(11, len(samcols)): + if samcols[j].startswith("Yt:Z:"): + samcols[j] = "Yt:Z:DD" + return pairsam_format.SAM_SEP.join(samcols) \ No newline at end of file diff --git a/pairtools/lib/filterbycov.py b/pairtools/lib/filterbycov.py index ddc6bbb2..9b50605d 100644 --- a/pairtools/lib/filterbycov.py +++ b/pairtools/lib/filterbycov.py @@ -1,7 +1,7 @@ import numpy as np import warnings -from .markasdup import mark_split_pair_as_dup +from .dedup import mark_split_pair_as_dup from . import pairsam_format @@ -226,7 +226,7 @@ def streaming_filterbycov( ) if outstream_high: outstream_high.write( - # FF-marked pair: + # DD-marked pair: sep.join(mark_split_pair_as_dup(cols_buffer[i])) if mark_multi # pair as is: diff --git a/pairtools/lib/markasdup.py b/pairtools/lib/markasdup.py deleted file mode 100644 index 8f87c5e2..00000000 --- a/pairtools/lib/markasdup.py +++ /dev/null @@ -1,40 +0,0 @@ -from . import pairsam_format - - -def mark_split_pair_as_dup(cols): - # if the original columns ended with a new line, the marked columns - # should as well. - original_has_newline = cols[-1].endswith("\n") - - cols[pairsam_format.COL_PTYPE] = "DD" - - if (len(cols) > pairsam_format.COL_SAM1) and (len(cols) > pairsam_format.COL_SAM2): - for i in (pairsam_format.COL_SAM1, pairsam_format.COL_SAM2): - - # split each sam column into sam entries, tag and assemble back - cols[i] = pairsam_format.INTER_SAM_SEP.join( - [ - mark_sam_as_dup(sam) - for sam in cols[i].split(pairsam_format.INTER_SAM_SEP) - ] - ) - - if original_has_newline and not cols[-1].endswith("\n"): - cols[-1] = cols[-1] + "\n" - return cols - - -def mark_sam_as_dup(sam): - """Tag the binary flag and the optional pair type field of a sam entry - as a PCR duplicate.""" - samcols = sam.split(pairsam_format.SAM_SEP) - - if len(samcols) == 1: - return sam - - samcols[1] = str(int(samcols[1]) | 1024) - - for j in range(11, len(samcols)): - if samcols[j].startswith("Yt:Z:"): - samcols[j] = "Yt:Z:DD" - return pairsam_format.SAM_SEP.join(samcols) From 4ee6d67dbbd5432ffadb2d3e38bbc813e03d8371 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 31 May 2022 21:34:50 -0400 Subject: [PATCH 51/52] dedup filter stats added and tested --- pairtools/cli/dedup.py | 171 ++++++++++++++++++++++++++++++----------- pairtools/cli/stats.py | 1 - 2 files changed, 124 insertions(+), 48 deletions(-) diff --git a/pairtools/cli/dedup.py b/pairtools/cli/dedup.py index 74bfe29a..e36b99b2 100644 --- a/pairtools/cli/dedup.py +++ b/pairtools/cli/dedup.py @@ -70,6 +70,7 @@ " By default, by-tile duplicate statistics are not printed." " Note that the readID should be provided and contain tile information for this option. ", ) + ### Set the dedup method: @click.option( "--max-mismatch", @@ -77,14 +78,14 @@ default=3, show_default=True, help="Pairs with both sides mapped within this distance (bp) from each " - "other are considered duplicates. ", + "other are considered duplicates. [dedup option]", ) @click.option( "--method", type=click.Choice(["max", "sum"]), default="max", help="define the mismatch as either the max or the sum of the mismatches of" - "the genomic locations of the both sides of the two compared molecules", + "the genomic locations of the both sides of the two compared molecules. [dedup option]", show_default=True, ) @click.option( @@ -101,7 +102,7 @@ " It is available for backwards compatibility and to allow specification of the" " column order." " Now the default scipy backend is generally the fastest, and with chunksize below" - " 1 mln has the lowest memory requirements." + " 1 mln has the lowest memory requirements. [dedup option]" # " 'cython' is deprecated and provided for backwards compatibility", ) @@ -114,7 +115,7 @@ help="Number of pairs in each chunk. Reduce for lower memory footprint." " Below 10,000 performance starts suffering significantly and the algorithm might" " miss a few duplicates with non-zero --max-mismatch." - " Only works with '--backend scipy or sklearn'", + " Only works with '--backend scipy or sklearn'. [dedup option]", ) @click.option( "--carryover", @@ -123,7 +124,7 @@ show_default=True, help="Number of deduped pairs to carry over from previous chunk to the new chunk" " to avoid breaking duplicate clusters." - " Only works with '--backend scipy or sklearn'", + " Only works with '--backend scipy or sklearn'. [dedup option]", ) @click.option( "-p", @@ -131,7 +132,7 @@ type=int, default=1, help="Number of cores to use. Only applies with sklearn backend." - "Still needs testing whether it is ever useful.", + "Still needs testing whether it is ever useful. [dedup option]", ) ### Output options: @@ -139,13 +140,13 @@ "--mark-dups", is_flag=True, help='If specified, duplicate pairs are marked as DD in "pair_type" and ' - "as a duplicate in the sam entries.", + "as a duplicate in the sam entries. [output format option]", ) @click.option( "--keep-parent-id", is_flag=True, help="If specified, duplicate pairs are marked with the readID of the retained" - " deduped read in the 'parent_readID' field.", + " deduped read in the 'parent_readID' field. [output format option]", ) @click.option( "--extra-col-pair", @@ -156,7 +157,7 @@ "duplicates. Can be either provided as 0-based column indices or as column " 'names (requires the "#columns" header field). The option can be provided ' "multiple times if multiple column pairs must match. " - 'Example: --extra-col-pair "phase1" "phase2"', + 'Example: --extra-col-pair "phase1" "phase2". [output format option]', ) ### Input options: @@ -164,58 +165,58 @@ "--sep", type=str, default=pairsam_format.PAIRSAM_SEP_ESCAPE, - help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes) ", + help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes). [input format option]", ) @click.option( - "--comment-char", type=str, default="#", help="The first character of comment lines" + "--comment-char", type=str, default="#", help="The first character of comment lines. [input format option]" ) @click.option( "--send-header-to", type=click.Choice(["dups", "dedup", "both", "none"]), default="both", - help="Which of the outputs should receive header and comment lines", + help="Which of the outputs should receive header and comment lines. [input format option]", ) @click.option( "--c1", type=int, default=pairsam_format.COL_C1, help=f"Chrom 1 column; default {pairsam_format.COL_C1}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--c2", type=int, default=pairsam_format.COL_C2, help=f"Chrom 2 column; default {pairsam_format.COL_C2}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--p1", type=int, default=pairsam_format.COL_P1, help=f"Position 1 column; default {pairsam_format.COL_P1}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--p2", type=int, default=pairsam_format.COL_P2, help=f"Position 2 column; default {pairsam_format.COL_P2}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--s1", type=int, default=pairsam_format.COL_S1, help=f"Strand 1 column; default {pairsam_format.COL_S1}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--s2", type=int, default=pairsam_format.COL_S2, help=f"Strand 2 column; default {pairsam_format.COL_S2}" - " Only works with '--backend cython'", + " Only works with '--backend cython'. [input format option]", ) @click.option( "--unmapped-chrom", @@ -225,6 +226,65 @@ pairsam_format.UNMAPPED_CHROM ), ) + +# Output stats option +@click.option( + "--yaml/--no-yaml", + is_flag=True, + default=False, + help="Output stats in yaml format instead of table. [output stats format option]", +) + +# Filtering options for reporting stats: +@click.option( + "--filter", + default=None, + required=False, + multiple=True, + help="Filter stats with condition to apply to the data (similar to `pairtools select` or `pairtools stats`). " + "For non-YAML output only the first filter will be reported. [output stats filtering option] " + "Note that this will not change the deduplicated output pairs. " + """Example: pairtools dedup --yaml --filter 'unique:(pair_type=="UU")' --filter 'close:(pair_type=="UU") and (abs(pos1-pos2)<10)' --output-stats - test.pairs """, +) +@click.option( + "--engine", + default="pandas", + required=False, + help="Engine for regular expression parsing for stats filtering. " + "Python will provide you regex functionality, while pandas does not accept " + "custom funtctions and works faster. [output stats filtering option]", +) +@click.option( + "--chrom-subset", + type=str, + default=None, + required=False, + help="A path to a chromosomes file (tab-separated, 1st column contains " + "chromosome names) containing a chromosome subset of interest for stats filter. " + "If provided, additionally filter pairs with both sides originating from " + "the provided subset of chromosomes. This operation modifies the #chromosomes: " + "and #chromsize: header fields accordingly. " + "Note that this will not change the deduplicated output pairs. [output stats filtering option]" +) +@click.option( + "--startup-code", + type=str, + default=None, + required=False, + help="An auxiliary code to execute before filteringfor stats. " + "Use to define functions that can be evaluated in the CONDITION statement. [output stats filtering option]", +) +@click.option( + "-t", + "--type-cast", + type=(str, str), + default=(), + multiple=True, + help="Cast a given column to a given type for stats filtering. By default, only pos and mapq " + "are cast to int, other columns are kept as str. Provide as " + "-t , e.g. -t read_len1 int. Multiple entries are allowed. [output stats filtering option]", +) + @common_io_options def dedup( pairs_path, @@ -331,35 +391,23 @@ def dedup_py( send_header_to_dedup = send_header_to in ["both", "dedup"] send_header_to_dup = send_header_to in ["both", "dups"] - instream = ( - fileio.auto_open( - pairs_path, - mode="r", - nproc=kwargs.get("nproc_in"), - command=kwargs.get("cmd_in", None), - ) - if pairs_path - else sys.stdin + instream = fileio.auto_open( + pairs_path, + mode="r", + nproc=kwargs.get("nproc_in"), + command=kwargs.get("cmd_in", None), ) - outstream = ( - fileio.auto_open( - output, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output - else sys.stdout + outstream = fileio.auto_open( + output, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), ) - out_stats_stream = ( - fileio.auto_open( - output_stats, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), - ) - if output_stats - else None + out_stats_stream = fileio.auto_open( + output_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), ) bytile_dups = False @@ -376,7 +424,30 @@ def dedup_py( keep_parent_id = True # generate empty PairCounter if stats output is requested: - out_stat = PairCounter(bytile_dups=bytile_dups) if output_stats else None + if output_stats: + filter = kwargs.get("filter", None) + # Define filters and their properties + first_filter_name = "no_filter" # default filter name for full output + if filter is not None and len(filter) > 0: + first_filter_name = filter[0].split(":", 1)[0] + if len(filter) > 1 and not kwargs.get("yaml", False): + logger.warn( + f"Output the first filter only in non-YAML output: {first_filter_name}" + ) + + filter = dict([f.split(":", 1) for f in filter]) + else: + filter = None + + out_stat = PairCounter( + bytile_dups=bytile_dups, + filters=filter, + startup_code=kwargs.get("startup_code", ""), # for evaluation of filters + type_cast=kwargs.get("type_cast", ()), # for evaluation of filters + engine=kwargs.get("engine", "pandas"), + ) + else: + out_stat = None if not output_dups: outstream_dups = None @@ -488,7 +559,13 @@ def dedup_py( # save statistics to a file if it was requested: if out_stat: - out_stat.save(out_stats_stream) + out_stat.save( + outstream, + yaml=kwargs.get("yaml", False), # format as yaml + filter=first_filter_name + if not kwargs.get("yaml", False) + else None, # output only the first filter if non-YAML output + ) if bytile_dups: out_stat.save_bytile_dups(out_bytile_stats_stream) diff --git a/pairtools/cli/stats.py b/pairtools/cli/stats.py index 7252106f..5f02fb04 100644 --- a/pairtools/cli/stats.py +++ b/pairtools/cli/stats.py @@ -182,7 +182,6 @@ def stats_py( else: filter = None - # new stats class stuff would come here ... stats = PairCounter( bytile_dups=bytile_dups, filters=filter, From ce150c37a868122c781dcea7c90377f25a421885 Mon Sep 17 00:00:00 2001 From: Aleksandra Galitsyna Date: Tue, 31 May 2022 21:36:52 -0400 Subject: [PATCH 52/52] Black --- pairtools/__main__.py | 2 +- pairtools/cli/dedup.py | 24 +++++++++++------- pairtools/cli/parse.py | 7 +---- pairtools/cli/phase.py | 45 +++++++++++++++++++++++---------- pairtools/cli/scaling.py | 10 +++++--- pairtools/lib/dedup.py | 7 ++--- pairtools/lib/headerops.py | 20 ++++++++++----- pairtools/lib/pairsam_format.py | 28 ++++++++++++++++---- pairtools/lib/parse.py | 23 +++++++++-------- pairtools/lib/phase.py | 35 ++++++++++++------------- pairtools/lib/restrict.py | 1 + pairtools/lib/scaling.py | 7 +++-- 12 files changed, 131 insertions(+), 78 deletions(-) diff --git a/pairtools/__main__.py b/pairtools/__main__.py index 7e34ccd6..98dcca0c 100644 --- a/pairtools/__main__.py +++ b/pairtools/__main__.py @@ -1,4 +1,4 @@ from .cli import cli if __name__ == "__main__": - cli() \ No newline at end of file + cli() diff --git a/pairtools/cli/dedup.py b/pairtools/cli/dedup.py index e36b99b2..43598065 100644 --- a/pairtools/cli/dedup.py +++ b/pairtools/cli/dedup.py @@ -6,6 +6,7 @@ import pathlib from .._logging import get_logger + logger = get_logger() from ..lib import fileio, pairsam_format, headerops @@ -165,10 +166,14 @@ "--sep", type=str, default=pairsam_format.PAIRSAM_SEP_ESCAPE, - help=r"Separator (\t, \v, etc. characters are " "supported, pass them in quotes). [input format option]", + help=r"Separator (\t, \v, etc. characters are " + "supported, pass them in quotes). [input format option]", ) @click.option( - "--comment-char", type=str, default="#", help="The first character of comment lines. [input format option]" + "--comment-char", + type=str, + default="#", + help="The first character of comment lines. [input format option]", ) @click.option( "--send-header-to", @@ -264,7 +269,7 @@ "If provided, additionally filter pairs with both sides originating from " "the provided subset of chromosomes. This operation modifies the #chromosomes: " "and #chromsize: header fields accordingly. " - "Note that this will not change the deduplicated output pairs. [output stats filtering option]" + "Note that this will not change the deduplicated output pairs. [output stats filtering option]", ) @click.option( "--startup-code", @@ -284,7 +289,6 @@ "are cast to int, other columns are kept as str. Provide as " "-t , e.g. -t read_len1 int. Multiple entries are allowed. [output stats filtering option]", ) - @common_io_options def dedup( pairs_path, @@ -413,14 +417,16 @@ def dedup_py( bytile_dups = False if output_bytile_stats: out_bytile_stats_stream = fileio.auto_open( - output_bytile_stats, - mode="w", - nproc=kwargs.get("nproc_out"), - command=kwargs.get("cmd_out", None), + output_bytile_stats, + mode="w", + nproc=kwargs.get("nproc_out"), + command=kwargs.get("cmd_out", None), ) bytile_dups = True if not keep_parent_id: - logger.warning("Force output --parent-readID because --output-bytile-stats provided.") + logger.warning( + "Force output --parent-readID because --output-bytile-stats provided." + ) keep_parent_id = True # generate empty PairCounter if stats output is requested: diff --git a/pairtools/cli/parse.py b/pairtools/cli/parse.py index 529d6dc2..567e5e2f 100644 --- a/pairtools/cli/parse.py +++ b/pairtools/cli/parse.py @@ -269,12 +269,7 @@ def parse_py( ### Parse input and write to the outputs streaming_classify( - input_sam, - outstream, - chromosomes, - out_alignments_stream, - out_stat, - **kwargs + input_sam, outstream, chromosomes, out_alignments_stream, out_stat, **kwargs ) # save statistics to a file if it was requested: diff --git a/pairtools/cli/phase.py b/pairtools/cli/phase.py index 404adfc5..9f33e7cc 100644 --- a/pairtools/cli/phase.py +++ b/pairtools/cli/phase.py @@ -9,6 +9,7 @@ UTIL_NAME = "pairtools_phase" + @cli.command() @click.argument("pairs_path", type=str, required=False) @click.option( @@ -47,10 +48,12 @@ is_flag=True, default=False, help="Report scores of optional, suboptimal and second suboptimal alignments. " - "NM (edit distance) with --tag-mode XA and AS (alfn score) with --tag-mode XB ", + "NM (edit distance) with --tag-mode XA and AS (alfn score) with --tag-mode XB ", ) @common_io_options -def phase(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): +def phase( + pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs +): """Phase pairs mapped to a diploid genome. Diploid genome is the genome with two set of the chromosome variants, where each chromosome has one of two suffixes (phase-suffixes) @@ -70,14 +73,24 @@ def phase(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_sco input is decompressed by bgzip/lz4c. By default, the input is read from stdin. """ - phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs) + phase_py( + pairs_path, + output, + phase_suffixes, + clean_output, + tag_mode, + report_scores, + **kwargs + ) if __name__ == "__main__": phase() -def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs): +def phase_py( + pairs_path, output, phase_suffixes, clean_output, tag_mode, report_scores, **kwargs +): instream = ( fileio.auto_open( @@ -111,9 +124,7 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ col for col in old_column_names if col in pairsam_format.COLUMNS ] new_column_idxs = [ - i - for i, col in enumerate(old_column_names) - if col in pairsam_format.COLUMNS + i for i, col in enumerate(old_column_names) if col in pairsam_format.COLUMNS ] new_column_idxs += [idx_phase1, idx_phase2] else: @@ -123,7 +134,7 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ new_column_names.append("phase2") if report_scores: - if tag_mode=="XB": + if tag_mode == "XB": new_column_names.append("S1_1") new_column_names.append("S1_2") new_column_names.append("S2_1") @@ -132,7 +143,7 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ new_column_names.append("S3_2") if clean_output: new_column_idxs += [(idx_phase2 + i + 1) for i in range(6)] - elif tag_mode=="XA": + elif tag_mode == "XA": new_column_names.append("M1_1") new_column_names.append("M1_2") new_column_names.append("M2_1") @@ -222,8 +233,12 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ if not report_scores: cols[idx_phase1] = phase1 else: - cols[idx_phase1], cols[idx_phase1+2], cols[idx_phase1+4], cols[idx_phase1+6] \ - = phase1, str(S1_1), str(S2_1), str(S3_1) + ( + cols[idx_phase1], + cols[idx_phase1 + 2], + cols[idx_phase1 + 4], + cols[idx_phase1 + 6], + ) = (phase1, str(S1_1), str(S2_1), str(S3_1)) cols[pairsam_format.COL_C1] = chrom_base1 if chrom_base1 == "!": @@ -254,8 +269,12 @@ def phase_py(pairs_path, output, phase_suffixes, clean_output, tag_mode, report_ if not report_scores: cols[idx_phase2] = phase2 else: - cols[idx_phase2], cols[idx_phase2+2], cols[idx_phase2+4], cols[idx_phase2+6] \ - = phase2, str(S1_2), str(S2_2), str(S3_2) + ( + cols[idx_phase2], + cols[idx_phase2 + 2], + cols[idx_phase2 + 4], + cols[idx_phase2 + 6], + ) = (phase2, str(S1_2), str(S2_2), str(S3_2)) cols[pairsam_format.COL_C2] = chrom_base2 if chrom_base2 == "!": diff --git a/pairtools/cli/scaling.py b/pairtools/cli/scaling.py index 2840a131..781bd139 100644 --- a/pairtools/cli/scaling.py +++ b/pairtools/cli/scaling.py @@ -16,15 +16,17 @@ @cli.command() @click.argument("input_path", type=str, nargs=-1, required=False) -@click.option("-o", "--output", type=str, default="", help="output .tsv file with summary.") +@click.option( + "-o", "--output", type=str, default="", help="output .tsv file with summary." +) @click.option( "--view", "--regions", help="Path to a BED file which defines which regions (viewframe) of the chromosomes to use. " - "By default, this is parsed from .pairs header. ", + "By default, this is parsed from .pairs header. ", type=str, required=False, - default=None + default=None, ) @click.option( "--chunksize", @@ -94,7 +96,7 @@ def scaling_py(input_path, output, view, chunksize, dist_range, n_dist_bins, **k summary_stats = pd.concat([cis_scalings, trans_levels]) # save statistics to the file - summary_stats.to_csv(outstream, sep='\t') + summary_stats.to_csv(outstream, sep="\t") if instream != sys.stdin: instream.close() diff --git a/pairtools/lib/dedup.py b/pairtools/lib/dedup.py index 53aaf8d3..b6d3e6dc 100644 --- a/pairtools/lib/dedup.py +++ b/pairtools/lib/dedup.py @@ -9,6 +9,7 @@ from .stats import PairCounter from .._logging import get_logger + logger = get_logger() import time @@ -97,7 +98,7 @@ def streaming_dedup( t1 = time.time() t = t1 - t0 logger.debug(f"total time: {t}") - if N>0: + if N > 0: logger.debug(f"time per mln pairs: {t/N*1e6}") else: logger.debug(f"Processed {N} pairs") @@ -529,7 +530,7 @@ def streaming_dedup_cython( t1 = time.time() t = t1 - t0 logger.debug(f"total time: {t}") - if N>0: + if N > 0: logger.debug(f"time per mln pairs: {t/N*1e6}") else: logger.debug(f"Processed {N} pairs") @@ -583,4 +584,4 @@ def mark_sam_as_dup(sam): for j in range(11, len(samcols)): if samcols[j].startswith("Yt:Z:"): samcols[j] = "Yt:Z:DD" - return pairsam_format.SAM_SEP.join(samcols) \ No newline at end of file + return pairsam_format.SAM_SEP.join(samcols) diff --git a/pairtools/lib/headerops.py b/pairtools/lib/headerops.py index 502e3b83..f7b7336f 100644 --- a/pairtools/lib/headerops.py +++ b/pairtools/lib/headerops.py @@ -12,6 +12,7 @@ from .fileio import ParseError from .._logging import get_logger + logger = get_logger() PAIRS_FORMAT_VERSION = "1.0.0" @@ -19,6 +20,7 @@ SEP_CHROMS = " " COMMENT_CHAR = "#" + def get_stream_handlers(instream): # get peekable buffer for the instream readline_f, peek_f = None, None @@ -32,6 +34,7 @@ def get_stream_handlers(instream): raise ValueError("Cannot find the peek() function of the provided stream!") return readline_f, peek_f + def get_header(instream, comment_char=COMMENT_CHAR, ignore_warning=False): """Returns a header from the stream and an the reaminder of the stream with the actual data. @@ -73,8 +76,10 @@ def get_header(instream, comment_char=COMMENT_CHAR, ignore_warning=False): # apparently, next line does not start with the comment # return header and the instream, advanced to the beginning of the data - if len(header)==0 and not ignore_warning: - logger.warning("Headerless input, please, add the header by `pairtools header generate` or `pairtools header transfer`") + if len(header) == 0 and not ignore_warning: + logger.warning( + "Headerless input, please, add the header by `pairtools header generate` or `pairtools header transfer`" + ) return header, instream @@ -146,9 +151,11 @@ def validate_cols(stream, columns): line = line.decode() ncols_body = len(line.split(pairsam_format.PAIRSAM_SEP)) - ncols_reference = len(columns) if isinstance(columns, list) else columns.split(SEP_COLS) + ncols_reference = ( + len(columns) if isinstance(columns, list) else columns.split(SEP_COLS) + ) - return ncols_body==ncols_reference + return ncols_body == ncols_reference def validate_header_cols(stream, header): @@ -159,7 +166,7 @@ def validate_header_cols(stream, header): def is_empty_header(header): - if len(header)==0: + if len(header) == 0: return True if not header[0].startswith("##"): return True @@ -781,9 +788,10 @@ def set_columns(header, columns): """ for i in range(len(header)): if header[i].startswith("#columns:"): - header[i] = "#columns:"+ SEP_COLS + SEP_COLS.join(columns) + header[i] = "#columns:" + SEP_COLS + SEP_COLS.join(columns) return header + # def _guess_genome_assembly(samheader): # PG = [l for l in samheader if l.startswith('@PG') and '\tID:bwa' in l][0] # CL = [field for field in PG.split('\t') if field.startswith('CL:')] diff --git a/pairtools/lib/pairsam_format.py b/pairtools/lib/pairsam_format.py index 6f4479a4..dfbd95ec 100644 --- a/pairtools/lib/pairsam_format.py +++ b/pairtools/lib/pairsam_format.py @@ -29,15 +29,33 @@ "sam1", "sam2", "walk_pair_index", - "walk_pair_type" + "walk_pair_type", ] # Required columns for formats: -COLUMNS_PAIRSAM = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', - 'strand1', 'strand2', 'pair_type', 'sam1', 'sam2'] +COLUMNS_PAIRSAM = [ + "readID", + "chrom1", + "pos1", + "chrom2", + "pos2", + "strand1", + "strand2", + "pair_type", + "sam1", + "sam2", +] -COLUMNS_PAIRS = ['readID', 'chrom1', 'pos1', 'chrom2', 'pos2', - 'strand1', 'strand2', 'pair_type'] +COLUMNS_PAIRS = [ + "readID", + "chrom1", + "pos1", + "chrom2", + "pos2", + "strand1", + "strand2", + "pair_type", +] UNMAPPED_CHROM = "!" UNMAPPED_POS = 0 diff --git a/pairtools/lib/parse.py b/pairtools/lib/parse.py index 2f79a650..493ada44 100644 --- a/pairtools/lib/parse.py +++ b/pairtools/lib/parse.py @@ -75,9 +75,9 @@ def streaming_classify( ) ) add_columns = kwargs.get("add_columns", "") - if isinstance(add_columns, str) and len(add_columns)>0: + if isinstance(add_columns, str) and len(add_columns) > 0: add_columns = add_columns.split(",") - elif len(add_columns)==0: + elif len(add_columns) == 0: add_columns = [] elif not isinstance(add_columns, list): raise ValueError(f"Unknown type of add_columns: {type(add_columns)}") @@ -458,7 +458,7 @@ def parse_read( # Walk was rescued as a simple walk: if rescued_linear_side is not None: - pair_index = (1, "R1" if rescued_linear_side==1 else "R2") + pair_index = (1, "R1" if rescued_linear_side == 1 else "R2") # Walk is unrescuable: else: if walks_policy == "mask": @@ -915,7 +915,7 @@ def parse_complex_walk( if ( n_algns1 >= 2 ): # single alignment on right read and multiple alignments on left - pair_index = (len(algns1)-1, "R1") + pair_index = (len(algns1) - 1, "R1") output_pairs.append( format_pair( algns1[-2], @@ -1001,12 +1001,15 @@ def parse_complex_walk( for i in reporting_order: # Determine the pair index depending on what is the overlap: shift = -1 if current_right_pair > 1 else 0 - pair_index = (( - n_algns1 - + min(current_right_pair, n_algns2 - last_reported_alignment_right) - - i - + shift - ), "R2") + pair_index = ( + ( + n_algns1 + + min(current_right_pair, n_algns2 - last_reported_alignment_right) + - i + + shift + ), + "R2", + ) output_pairs.append( format_pair( algns2[i + 1], diff --git a/pairtools/lib/phase.py b/pairtools/lib/phase.py index e3aa3bcc..d08a9f45 100644 --- a/pairtools/lib/phase.py +++ b/pairtools/lib/phase.py @@ -11,36 +11,33 @@ def phase_side_XB(chrom, XB, AS, XS, phase_suffixes): phase, chrom_base = get_chrom_phase(chrom, phase_suffixes) - XBs = [i for i in XB.split(';') if len(i) > 0] - S1, S2, S3 = AS, XS, -1 # -1 if the second hit was not reported + XBs = [i for i in XB.split(";") if len(i) > 0] + S1, S2, S3 = AS, XS, -1 # -1 if the second hit was not reported - if AS > XS: # Primary hit has higher score than the secondary + if AS > XS: # Primary hit has higher score than the secondary return phase, chrom_base, S1, S2, S3 elif len(XBs) >= 1: if len(XBs) >= 2: - alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS, alt_mapq = XBs[1].split(',') + alt2_chrom, alt2_pos, alt2_CIGAR, alt2_NM, alt2_AS, alt_mapq = XBs[1].split( + "," + ) S3 = int(alt2_AS) if int(alt2_AS) == XS == AS: - return '!', '!', S1, S2, S3 + return "!", "!", S1, S2, S3 - alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS, alt_mapq = XBs[0].split(',') + alt_chrom, alt_pos, alt_CIGAR, alt_NM, alt_AS, alt_mapq = XBs[0].split(",") alt_phase, alt_chrom_base = get_chrom_phase(alt_chrom, phase_suffixes) - alt_is_homologue = ( - (chrom_base == alt_chrom_base) - and - ( - ((phase == '0') and (alt_phase == '1')) - or - ((phase == '1') and (alt_phase == '0')) - ) + alt_is_homologue = (chrom_base == alt_chrom_base) and ( + ((phase == "0") and (alt_phase == "1")) + or ((phase == "1") and (alt_phase == "0")) ) if alt_is_homologue: - return '.', chrom_base, S1, S2, S3 + return ".", chrom_base, S1, S2, S3 - return '!', '!', S1, S2, S3 + return "!", "!", S1, S2, S3 def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): @@ -52,9 +49,9 @@ def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): alt_chrom, alt_pos, alt_CIGAR, alt_NM = XAs[0].split(",") M1, M2, M3 = NM, int(alt_NM), -1 else: - M1, M2, M3 = NM, -1, -1 # -1 if the second hit was not reported + M1, M2, M3 = NM, -1, -1 # -1 if the second hit was not reported - if (AS > XS): # Primary hit has higher score than the secondary + if AS > XS: # Primary hit has higher score than the secondary return phase, chrom_base, M1, M2, M3 elif len(XAs) >= 1: @@ -77,4 +74,4 @@ def phase_side_XA(chrom, XA, AS, XS, NM, phase_suffixes): if alt_is_homologue: return ".", chrom_base, M1, M2, M3 - return "!", "!", M1, M2, M3 \ No newline at end of file + return "!", "!", M1, M2, M3 diff --git a/pairtools/lib/restrict.py b/pairtools/lib/restrict.py index 986da2d9..97943981 100644 --- a/pairtools/lib/restrict.py +++ b/pairtools/lib/restrict.py @@ -1,6 +1,7 @@ from . import pairsam_format import warnings + def find_rfrag(rfrags, chrom, pos): # Return empty if chromosome is unmapped: diff --git a/pairtools/lib/scaling.py b/pairtools/lib/scaling.py index d6aed5b3..2fefda22 100644 --- a/pairtools/lib/scaling.py +++ b/pairtools/lib/scaling.py @@ -4,6 +4,7 @@ from .regions import assign_regs_c import bioframe + def geomprog(factor, start=1): yield start while True: @@ -165,9 +166,11 @@ def bins_pairs_by_distance( try: regions = bioframe.from_any(regions) except Exception as e: - raise ValueError(f"Provided regions cannot be converted to viewframe, {e}") + raise ValueError( + f"Provided regions cannot be converted to viewframe, {e}" + ) - regions = regions[['chrom', 'start', 'end']] + regions = regions[["chrom", "start", "end"]] _, region_starts1, region_ends1 = assign_regs( pairs_df.chrom1.values, pairs_df.pos1.values, regions