From f2f0ecd697e945931bf53642ea5a2ec7e1326289 Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Sun, 13 Apr 2025 18:57:16 +0200
Subject: [PATCH 01/15] change auto_open, add CommandFormatter and
 CommandRunResult, add some typisation

---
 pairtools/lib/fileio.py | 269 +++++++++++++++++++---------------------
 1 file changed, 127 insertions(+), 142 deletions(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index c49bc10a..4d3d6fd7 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -1,156 +1,141 @@
 import shutil
-import pipes
 import subprocess
+import shlex
 import sys
+import typing as tp
+from dataclasses import dataclass
 
 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
-    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
-    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
-    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
-    .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()
-            t.append(command, "--")
-            f = t.open(path, "w")
-        elif mode == "r":
-            t = pipes.Template()
-            t.append(command, "--")
-            f = t.open(path, "r")
+MODES_TO_FILES_PRESET = {
+    'bam': ['w', 'r'],
+    'gz': ['w', 'r', 'a'],
+    'lz4': ['w', 'r', 'a'],
+}
+
+COMMANDS = {
+    ('bam', 'w'): [
+        {'tool': 'samtools', 'command': 'samtools view -bS {} -'}
+    ],
+    ('bam', 'r'): [
+        {'tool': 'samtools', 'command': 'samtools view -h'}
+    ],
+    ('gz', 'w'): [
+        {'tool': 'pbgzip', 'command': 'pbgzip -c -n {}'},
+        {'tool': 'bgzip', 'command': 'bgzip -c -@ {}'},
+        {'tool': 'gzip', 'command': 'gzip -c'}
+    ],
+    ('gz', 'a'): [
+        {'tool': 'pbgzip', 'command': 'pbgzip -c -n {}'},
+        {'tool': 'bgzip', 'command': 'bgzip -c -@ {}'},
+        {'tool': 'gzip', 'command': 'gzip -c'}
+    ],
+    ('gz', 'r'): [
+        {'tool': 'pbgzip', 'command': 'pbgzip -dc -n {}'},
+        {'tool': 'bgzip', 'command': 'bgzip -dc -@ {}'},
+        {'tool': 'gzip', 'command': 'gzip -dc'}
+    ],
+    ('lz4', 'w'): [
+        {'tool': 'lz4c', 'command': 'lz4c -cz'}
+    ],
+    ('lz4', 'a'): [
+        {'tool': 'lz4c', 'command': 'lz4c -cz'}
+    ],
+    ('lz4', 'r'): [
+        {'tool': 'lz4c', 'command': 'lz4c -cd'}
+    ]
+}
+
+
+@dataclass
+class CommandRunResult:
+    errors: tp.Optional[bytes]
+    output: tp.Optional[bytes]
+    outfile: tp.Optional[tp.TextIO]
+
+
+@dataclass
+class CommandFormatter():
+
+    mode: tp.Optional[tp.Literal['r', 'w', 'a']]
+    path: tp.Optional[str]=None
+    command: tp.Optional[tp.Union[tp.List[str], str]]=None
+    nproc: int=1
+    is_binary: bool=False
+
+    @staticmethod
+    def form_notfounderror_text(searched_tools: tp.List[str], is_read: bool) -> str:
+        tools_article = 'is' if len(searched_tools) == 1 else 'are'
+        tools_defenition = 'compress output' if is_read else 'decompress input'
+        tools_list = f'{', '.join(searched_tools[:-1])} and {searched_tools[-1]}' if len(searched_tools) > 1 else searched_tools[0]
+        return f"{tools_list} {tools_article} not found, cannot {tools_defenition}"
+
+    def __post_init__(self):
+        self.__nocommand = False
+        if self.is_binary:
+            self.file_mode = f'{self.mode}b'
         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":
-            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 = pipes.Template()
-            t.append("samtools view -h", "--")
-            f = t.open(path, "r")
+            self.file_mode = self.mode
+
+        if self.command:
+            return
+        
+        self.__format = self.path.split('.')[-1]
+
+        if self.__format not in MODES_TO_FILES_PRESET.keys():
+            self.__nocommand = True
+            return
+        if (self.__format, self.mode) not in COMMANDS.keys():
+            raise ValueError(f'{self.__format} can not to be opened in {self.mode}')
+        
+        checked_tools = []
+        for possible_solution in COMMANDS[(self.__format, self.mode)]:
+            if shutil.which(possible_solution['tool']) is None:
+                checked_tools.append(possible_solution['tool'])
+                continue
+            self.command = possible_solution['command'].format(str(self.nproc))
+            return
+
+        raise ValueError(self.form_notfounderror_text(checked_tools, self.mode=='r'))
+    
+    def __convert_command(self):
+        if isinstance(self.command, str):
+            self.__command_to_sp = shlex.split(self.command)
         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":
-                t = pipes.Template()
-                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 = pipes.Template()
-                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":
-                t = pipes.Template()
-                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 = pipes.Template()
-                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":
-                t = pipes.Template()
-                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 = pipes.Template()
-                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]
-            )
-        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":
-            t = pipes.Template()
-            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 = pipes.Template()
-            t.append("lz4c -cd", "--")
-            f = t.open(path, "r")
+            self.__command_to_sp = self.command
+
+    def __form_command(self):
+        self.__process_file = open(self.path, self.file_mode)
+        if self.mode == 'r':
+            print('read')
+            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE)
         else:
-            raise ValueError("Unknown mode : {}".format(mode))
-        return f
-    else:
-        return open(path, mode)
+            print('write')
+            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE)
+        return cmd
+    
+    def __call__(self):
+        if not self.path or self.path == "-":
+            if self.mode == "r":
+                return CommandRunResult(errors=None, output=None, outfile=sys.stdin)
+            if self.mode == "w":
+                return CommandRunResult(errors=None, output=None, outfile=sys.stdout)
+            if self.mode == "r":
+                return ValueError(f'Zero input file can not to be opened in a')
+        if self.__nocommand:
+            return CommandRunResult(errors=None, output=None, outfile=open(self.path, self.file_mode))
+        self.__convert_command()
+        process = self.__form_command()
+        out, err = process.communicate()
+        return CommandRunResult(errors=err, output=out, outfile=self.__process_file)
+
+
+def auto_open(path, mode, nproc=1, command=None):
+    command = CommandFormatter(mode=mode, path=path, command=command, nproc=nproc)
+    result = command()
+    return result.outfile
 
 
 class PipedIO:

From 344d871704576c95706f2525c671a2489d39a1e5 Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Sun, 13 Apr 2025 19:20:01 +0200
Subject: [PATCH 02/15] change f-strings

---
 pairtools/lib/fileio.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 4d3d6fd7..fa65fc1f 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -69,7 +69,7 @@ class CommandFormatter():
     def form_notfounderror_text(searched_tools: tp.List[str], is_read: bool) -> str:
         tools_article = 'is' if len(searched_tools) == 1 else 'are'
         tools_defenition = 'compress output' if is_read else 'decompress input'
-        tools_list = f'{', '.join(searched_tools[:-1])} and {searched_tools[-1]}' if len(searched_tools) > 1 else searched_tools[0]
+        tools_list = f'{"", "".join(searched_tools[:-1])} and {searched_tools[-1]}' if len(searched_tools) > 1 else searched_tools[0]
         return f"{tools_list} {tools_article} not found, cannot {tools_defenition}"
 
     def __post_init__(self):

From 5bf68a075b14bdc55ca0a93245a7e4c09a07a6f9 Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Thu, 17 Apr 2025 21:16:41 +0200
Subject: [PATCH 03/15] add correct file logics, remove prints

---
 pairtools/lib/fileio.py | 36 ++++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index fa65fc1f..4b69654e 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -51,15 +51,24 @@ class ParseError(Exception):
 
 @dataclass
 class CommandRunResult:
-    errors: tp.Optional[bytes]
-    output: tp.Optional[bytes]
+    errors: tp.Optional[tp.TextIO]
+    output: tp.Optional[tp.TextIO]
+    input: tp.Optional[tp.TextIO]
+    mode: tp.Optional[tp.Literal['r', 'w', 'a']]
+
+    @property
+    def outfile(self) -> tp.Optional[tp.TextIO]:
+        if self.mode=='r':
+            return self.input
+        if self.mode=='w' or self.mode=='a':
+            return self.output
     outfile: tp.Optional[tp.TextIO]
 
 
 @dataclass
 class CommandFormatter():
 
-    mode: tp.Optional[tp.Literal['r', 'w', 'a']]
+    mode: tp.Literal['r', 'w', 'a']
     path: tp.Optional[str]=None
     command: tp.Optional[tp.Union[tp.List[str], str]]=None
     nproc: int=1
@@ -109,27 +118,22 @@ def __convert_command(self):
     def __form_command(self):
         self.__process_file = open(self.path, self.file_mode)
         if self.mode == 'r':
-            print('read')
-            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE)
+            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         else:
-            print('write')
-            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE)
+            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
         return cmd
     
     def __call__(self):
         if not self.path or self.path == "-":
-            if self.mode == "r":
-                return CommandRunResult(errors=None, output=None, outfile=sys.stdin)
-            if self.mode == "w":
-                return CommandRunResult(errors=None, output=None, outfile=sys.stdout)
-            if self.mode == "r":
-                return ValueError(f'Zero input file can not to be opened in a')
+            return CommandRunResult(input=sys.stdin, errors=None, output=sys.stdout, mode=self.mode)
         if self.__nocommand:
-            return CommandRunResult(errors=None, output=None, outfile=open(self.path, self.file_mode))
+            self.__process_file = open(self.path, self.file_mode)
+            if self.mode=='r':
+                return CommandRunResult(input=self.__process_file, errors=None, output=None, mode=self.mode)
+            return CommandRunResult(input=None, errors=None, output=self.__process_file, mode=self.mode)
         self.__convert_command()
         process = self.__form_command()
-        out, err = process.communicate()
-        return CommandRunResult(errors=err, output=out, outfile=self.__process_file)
+        return CommandRunResult(input=process.stdin, errors=process.stderr, output=process.stdout, mode=self.mode)
 
 
 def auto_open(path, mode, nproc=1, command=None):

From 23da0d3294861f2da349f528c788b9e1d4b446ae Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Thu, 17 Apr 2025 21:18:04 +0200
Subject: [PATCH 04/15] remove misclick row

---
 pairtools/lib/fileio.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 4b69654e..7dc1fb6c 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -62,7 +62,6 @@ def outfile(self) -> tp.Optional[tp.TextIO]:
             return self.input
         if self.mode=='w' or self.mode=='a':
             return self.output
-    outfile: tp.Optional[tp.TextIO]
 
 
 @dataclass

From f3c8f61ef9b9794aebe448727ae2c7f5a341f234 Mon Sep 17 00:00:00 2001
From: agalitsyna <agalitzina@gmail.com>
Date: Mon, 21 Apr 2025 14:29:50 -0400
Subject: [PATCH 05/15] Update _logging.py

removing the global definition of loggers to satisfy latest flake8 update
---
 pairtools/_logging.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/pairtools/_logging.py b/pairtools/_logging.py
index bfaf39f8..90cb3c24 100644
--- a/pairtools/_logging.py
+++ b/pairtools/_logging.py
@@ -1,11 +1,12 @@
 import logging
 
-_loggers = {}
+# _loggers = {}
 
 
 def get_logger(name="pairtools"):
     # Based on ipython traitlets
-    global _loggers
+    # global _loggers
+    _loggers = {}
 
     if name not in _loggers:
         _loggers[name] = logging.getLogger(name)

From 1bc9f229658db1c703ae4425277f4e761cdf1efe Mon Sep 17 00:00:00 2001
From: agalitsyna <agalitzina@gmail.com>
Date: Mon, 21 Apr 2025 14:35:24 -0400
Subject: [PATCH 06/15] Update _logging.py

---
 pairtools/_logging.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pairtools/_logging.py b/pairtools/_logging.py
index 90cb3c24..fc1c312a 100644
--- a/pairtools/_logging.py
+++ b/pairtools/_logging.py
@@ -1,12 +1,11 @@
 import logging
 
-# _loggers = {}
+_loggers = {}
 
 
 def get_logger(name="pairtools"):
     # Based on ipython traitlets
     # global _loggers
-    _loggers = {}
 
     if name not in _loggers:
         _loggers[name] = logging.getLogger(name)

From 7c3816969c29f60aed5509d22d585dd1a1ef4e1d Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Tue, 29 Apr 2025 11:32:24 +0200
Subject: [PATCH 07/15] add some hints

---
 pairtools/lib/fileio.py | 73 +++++++++++++++++++++++++++++++++++++----
 1 file changed, 67 insertions(+), 6 deletions(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 7dc1fb6c..0da96aa9 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -9,12 +9,18 @@ class ParseError(Exception):
     pass
 
 
+# dictionary of allowed automatic opener formats and modes 
+# key is format, value is list with allowed modes
 MODES_TO_FILES_PRESET = {
     'bam': ['w', 'r'],
     'gz': ['w', 'r', 'a'],
     'lz4': ['w', 'r', 'a'],
 }
 
+# dictionary of automatic opener commands
+# key is tuple from fomat and mode and value is dictionary 
+# with keys tools - tool which we will try to find via shutil and command which will be formatted by thread number
+#WE NEED COVER
 COMMANDS = {
     ('bam', 'w'): [
         {'tool': 'samtools', 'command': 'samtools view -bS {} -'}
@@ -51,6 +57,21 @@ class ParseError(Exception):
 
 @dataclass
 class CommandRunResult:
+    """
+    CommandRunResult represents the outcome of executing a command, encapsulating the standard input, output, and error streams, along with the mode of operation.
+
+    Attributes:
+        errors (Optional[TextIO]): The standard error stream (stderr) of the process. Can be None if not applicable.
+        output (Optional[TextIO]): The standard output stream (stdout) of the process. Can be None if not applicable.
+        input (Optional[TextIO]): The standard input stream (stdin) of the process. Can be None if not applicable.
+        mode (Optional[Literal['r', 'w', 'a']]): The mode in which the file is opened: 'r' for reading, 'w' for writing, or 'a' for appending.
+
+    Properties:
+        outfile (Optional[TextIO]): Returns the appropriate file-like object based on the mode:
+            - 'r': Returns the output stream (stdout) for reading.
+            - 'w' or 'a': Returns the input stream (stdin) for writing or appending.
+    """
+
     errors: tp.Optional[tp.TextIO]
     output: tp.Optional[tp.TextIO]
     input: tp.Optional[tp.TextIO]
@@ -59,13 +80,26 @@ class CommandRunResult:
     @property
     def outfile(self) -> tp.Optional[tp.TextIO]:
         if self.mode=='r':
-            return self.input
-        if self.mode=='w' or self.mode=='a':
             return self.output
+        if self.mode=='w' or self.mode=='a':
+            return self.input
 
 
 @dataclass
 class CommandFormatter():
+    """
+    A class to manage file opening operations with support for various compression formats.
+
+    Attributes:
+        mode (str): Mode in which the file is to be opened ('r', 'w', or 'a').
+        path (Optional[str]): Path to the target file.
+        command (Optional[Union[List[str], str]]): Custom command for file processing.
+        nproc (int): Number of threads for multithreaded tools. Defaults to 1.
+        is_binary (bool): Indicates if the file should be opened in binary mode. Defaults to False.
+
+    Methods:
+        __call__(): Executes the command or opens the file based on the provided parameters. Return pairtools.lib.fileio.CommandRunResult object
+    """
 
     mode: tp.Literal['r', 'w', 'a']
     path: tp.Optional[str]=None
@@ -73,6 +107,8 @@ class CommandFormatter():
     nproc: int=1
     is_binary: bool=False
 
+    #Error textm formatter. If some bash tools is needed but not found, user catch error like SomeTool not found, cannot compress output
+    #This method is used to construct understandable error text
     @staticmethod
     def form_notfounderror_text(searched_tools: tp.List[str], is_read: bool) -> str:
         tools_article = 'is' if len(searched_tools) == 1 else 'are'
@@ -87,17 +123,23 @@ def __post_init__(self):
         else:
             self.file_mode = self.mode
 
+        #if we have command, just run it
         if self.command:
             return
         
         self.__format = self.path.split('.')[-1]
 
+        #if format not in MODES_TO_FILES_PRESET, we will return opened file in given mode
         if self.__format not in MODES_TO_FILES_PRESET.keys():
             self.__nocommand = True
             return
+        
+        #cannot open given format in given mode
         if (self.__format, self.mode) not in COMMANDS.keys():
             raise ValueError(f'{self.__format} can not to be opened in {self.mode}')
         
+        #iterate over tools. Function calling ends when tool is founded
+        #just forms self.command
         checked_tools = []
         for possible_solution in COMMANDS[(self.__format, self.mode)]:
             if shutil.which(possible_solution['tool']) is None:
@@ -106,6 +148,7 @@ def __post_init__(self):
             self.command = possible_solution['command'].format(str(self.nproc))
             return
 
+        #if we have no return (in iterate over tools), catch an error
         raise ValueError(self.form_notfounderror_text(checked_tools, self.mode=='r'))
     
     def __convert_command(self):
@@ -122,20 +165,38 @@ def __form_command(self):
             cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
         return cmd
     
-    def __call__(self):
+    def __call__(self) -> CommandRunResult:
         if not self.path or self.path == "-":
             return CommandRunResult(input=sys.stdin, errors=None, output=sys.stdout, mode=self.mode)
         if self.__nocommand:
             self.__process_file = open(self.path, self.file_mode)
-            if self.mode=='r':
-                return CommandRunResult(input=self.__process_file, errors=None, output=None, mode=self.mode)
-            return CommandRunResult(input=None, errors=None, output=self.__process_file, mode=self.mode)
+            return CommandRunResult(input=self.__process_file, errors=None, output=self.__process_file, mode=self.mode)
         self.__convert_command()
         process = self.__form_command()
         return CommandRunResult(input=process.stdin, errors=process.stderr, output=process.stdout, mode=self.mode)
 
 
 def auto_open(path, mode, nproc=1, command=None):
+    """
+    Automatically opens a file based on its format and access mode.
+
+    Determines the file format from its extension and selects the appropriate
+    command for reading or writing, utilizing available compression or
+    decompression tools. If a specific command is provided, it will be used
+    directly.
+
+    Parameters:
+        path (str): Path to the file or '-' for standard input/output.
+        mode (str): File access mode: 'r' (read), 'w' (write), or 'a' (append).
+        nproc (int, optional): Number of threads for multithreaded tools. Defaults to 1.
+        command (str or list, optional): Custom command for file processing. Defaults to None.
+
+    Returns:
+        file-like object: A file object ready for reading or writing data.
+
+    Raises:
+        ValueError: If the file format is unsupported or the required tool is not found.
+    """
     command = CommandFormatter(mode=mode, path=path, command=command, nproc=nproc)
     result = command()
     return result.outfile

From 3a66a980e7a8f5748923ea9e63dc65f869fde31e Mon Sep 17 00:00:00 2001
From: Egor Pitikov <egorpitikov@Egors-MacBook-Pro.local>
Date: Mon, 26 May 2025 19:38:01 +0200
Subject: [PATCH 08/15] change IO methods

---
 pairtools/lib/fileio.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 0da96aa9..e51ddf85 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -167,7 +167,7 @@ def __form_command(self):
     
     def __call__(self) -> CommandRunResult:
         if not self.path or self.path == "-":
-            return CommandRunResult(input=sys.stdin, errors=None, output=sys.stdout, mode=self.mode)
+            return CommandRunResult(input=sys.stdout, errors=None, output=sys.stdin, mode=self.mode)
         if self.__nocommand:
             self.__process_file = open(self.path, self.file_mode)
             return CommandRunResult(input=self.__process_file, errors=None, output=self.__process_file, mode=self.mode)

From 0eef5f47f1d14ad80ed2e1072a18913ceac595be Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Mon, 26 May 2025 19:42:09 +0200
Subject: [PATCH 09/15] decode text

---
 pairtools/lib/fileio.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index e51ddf85..d01ec15a 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -160,9 +160,9 @@ def __convert_command(self):
     def __form_command(self):
         self.__process_file = open(self.path, self.file_mode)
         if self.mode == 'r':
-            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         else:
-            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
+            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         return cmd
     
     def __call__(self) -> CommandRunResult:

From e2d826337b2940b7a283add4488192357ab46134 Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Mon, 16 Jun 2025 21:20:56 +0200
Subject: [PATCH 10/15] comments + -@ in bam w mode

---
 pairtools/lib/fileio.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index d01ec15a..684b0d8f 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -23,7 +23,7 @@ class ParseError(Exception):
 #WE NEED COVER
 COMMANDS = {
     ('bam', 'w'): [
-        {'tool': 'samtools', 'command': 'samtools view -bS {} -'}
+        {'tool': 'samtools', 'command': 'samtools view -bS -@ {} -'}
     ],
     ('bam', 'r'): [
         {'tool': 'samtools', 'command': 'samtools view -h'}
@@ -92,8 +92,9 @@ class CommandFormatter():
 
     Attributes:
         mode (str): Mode in which the file is to be opened ('r', 'w', or 'a').
-        path (Optional[str]): Path to the target file.
-        command (Optional[Union[List[str], str]]): Custom command for file processing.
+        path (Optional[str]): Path to the target file. Empty or '-' indicates standard input/output (for || case).
+        command (Optional[Union[List[str], str]]): Custom command for file processing. For some file formats we have default commands. If empty or None, the class will try to find a suitable command based on the file format and mode.
+        If a command is provided, it will be used directly.
         nproc (int): Number of threads for multithreaded tools. Defaults to 1.
         is_binary (bool): Indicates if the file should be opened in binary mode. Defaults to False.
 
@@ -166,8 +167,12 @@ def __form_command(self):
         return cmd
     
     def __call__(self) -> CommandRunResult:
+        # Empty path or path '-' means that we just read from stdin or write to stdout (for || case)
         if not self.path or self.path == "-":
+            # we will write at sys.stdout and read from sys.stdin it's strnga but...
             return CommandRunResult(input=sys.stdout, errors=None, output=sys.stdin, mode=self.mode)
+        # if we have no command, just open file in given mode
+        # nocammand means that there is empty cmd AND we have no format in MODES_TO_FILES_PRESET
         if self.__nocommand:
             self.__process_file = open(self.path, self.file_mode)
             return CommandRunResult(input=self.__process_file, errors=None, output=self.__process_file, mode=self.mode)

From 9ebac92e5ca5ae2c2d8db282177f6a015cb498f2 Mon Sep 17 00:00:00 2001
From: Reovirus <pitikovegor@gmail.com>
Date: Mon, 16 Jun 2025 22:23:38 +0200
Subject: [PATCH 11/15] comment about COMMANDS dict

---
 pairtools/lib/fileio.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 684b0d8f..4d87a48a 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -20,7 +20,7 @@ class ParseError(Exception):
 # dictionary of automatic opener commands
 # key is tuple from fomat and mode and value is dictionary 
 # with keys tools - tool which we will try to find via shutil and command which will be formatted by thread number
-#WE NEED COVER
+#dict ('file_format', 'mode'): 'command formatted to set threads number'
 COMMANDS = {
     ('bam', 'w'): [
         {'tool': 'samtools', 'command': 'samtools view -bS -@ {} -'}

From 163eb30ba198e5a566501aaaadf1dfeb076d599d Mon Sep 17 00:00:00 2001
From: Aleksandra Galitsyna <agalitzina@gmail.com>
Date: Mon, 16 Jun 2025 17:39:33 -0400
Subject: [PATCH 12/15] fileio code refactoring; improved readability; code
 simplified. scalings example tested and vis improved.

---
 doc/examples/scalings_example.ipynb |  84 +++++++++-------
 pairtools/lib/fileio.py             | 146 ++++++++++++++++++----------
 2 files changed, 140 insertions(+), 90 deletions(-)

diff --git a/doc/examples/scalings_example.ipynb b/doc/examples/scalings_example.ipynb
index 9476a02a..6feb3275 100644
--- a/doc/examples/scalings_example.ipynb
+++ b/doc/examples/scalings_example.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "metadata": {
     "vscode": {
      "languageId": "python"
@@ -13,15 +13,27 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "--2023-12-18 23:04:28--  https://osf.io/download/crgu8/\n",
+      "--2025-06-16 17:35:08--  https://osf.io/download/crgu8/\n",
       "Resolving osf.io (osf.io)... 35.190.84.173\n",
       "Connecting to osf.io (osf.io)|35.190.84.173|:443... connected.\n",
       "HTTP request sent, awaiting response... 302 FOUND\n",
       "Location: https://files.de-1.osf.io/v1/resources/638ue/providers/osfstorage/623993788d53ef082867e2b9 [following]\n",
-      "--2023-12-18 23:04:28--  https://files.de-1.osf.io/v1/resources/638ue/providers/osfstorage/623993788d53ef082867e2b9\n",
+      "--2025-06-16 17:35:09--  https://files.de-1.osf.io/v1/resources/638ue/providers/osfstorage/623993788d53ef082867e2b9\n",
       "Resolving files.de-1.osf.io (files.de-1.osf.io)... 35.186.249.111\n",
       "Connecting to files.de-1.osf.io (files.de-1.osf.io)|35.186.249.111|:443... connected.\n",
-      "HTTP request sent, awaiting response... "
+      "HTTP request sent, awaiting response... 302 Found\n",
+      "Location: https://storage.googleapis.com/cos-osf-prod-files-de-1/b72f21bb7e21d00541fb3cbc50ef77d67b75970f7d255912ca527fb4c8e5cc0a?response-content-disposition=attachment%3B%20filename%3D%22test_pairs.wp-all.pairs%22%3B%20filename%2A%3DUTF-8%27%27test_pairs.wp-all.pairs&GoogleAccessId=files-de-1%40cos-osf-prod.iam.gserviceaccount.com&Expires=1750109770&Signature=vj5xy0LEoxoGWERXB5r9UlyQtILbc3GLc2t8hw1zKhDpqzAvp80zh7fBorKymvaUrBahonP0IONT4MjKM6kl7SWkRJsvxtk2LpZyweyIZBk5gJleVySQMNn5W8OuflrgqjkhoIc77XIOSg89cv384mFG%2B66dx4btbJ7DevQJeUiX8oUOvMzJKeg18Ngsg3103jJnEA%2FrEw%2B%2BZZ5AQRBklt49z9lHOXuw0HkG33XW48mJuJUvSW7rt2vCKYus34s7xSEoOnTNtVCasFqdkb%2BaHxWWOQ7eDVwWTOaCvMj8JOeZRQbNKUx%2BIuT8wGjgo%2FOA%2FPO9oApdgCYqZU4KAozD%2Fg%3D%3D [following]\n",
+      "--2025-06-16 17:35:10--  https://storage.googleapis.com/cos-osf-prod-files-de-1/b72f21bb7e21d00541fb3cbc50ef77d67b75970f7d255912ca527fb4c8e5cc0a?response-content-disposition=attachment%3B%20filename%3D%22test_pairs.wp-all.pairs%22%3B%20filename%2A%3DUTF-8%27%27test_pairs.wp-all.pairs&GoogleAccessId=files-de-1%40cos-osf-prod.iam.gserviceaccount.com&Expires=1750109770&Signature=vj5xy0LEoxoGWERXB5r9UlyQtILbc3GLc2t8hw1zKhDpqzAvp80zh7fBorKymvaUrBahonP0IONT4MjKM6kl7SWkRJsvxtk2LpZyweyIZBk5gJleVySQMNn5W8OuflrgqjkhoIc77XIOSg89cv384mFG%2B66dx4btbJ7DevQJeUiX8oUOvMzJKeg18Ngsg3103jJnEA%2FrEw%2B%2BZZ5AQRBklt49z9lHOXuw0HkG33XW48mJuJUvSW7rt2vCKYus34s7xSEoOnTNtVCasFqdkb%2BaHxWWOQ7eDVwWTOaCvMj8JOeZRQbNKUx%2BIuT8wGjgo%2FOA%2FPO9oApdgCYqZU4KAozD%2Fg%3D%3D\n",
+      "Resolving storage.googleapis.com (storage.googleapis.com)... 142.251.40.155, 142.250.64.91, 142.250.64.123, ...\n",
+      "Connecting to storage.googleapis.com (storage.googleapis.com)|142.251.40.155|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 564902846 (539M) [application/octet-stream]\n",
+      "Saving to: ‘./test.pairs’\n",
+      "\n",
+      "./test.pairs        100%[===================>] 538.73M  43.0MB/s    in 13s     \n",
+      "\n",
+      "2025-06-16 17:35:23 (41.7 MB/s) - ‘./test.pairs’ saved [564902846/564902846]\n",
+      "\n"
      ]
     },
     {
@@ -45,12 +57,12 @@
     }
    ],
    "source": [
-    "!wget https://osf.io/download/crgu8/ -O ./tmp/test.pairs"
+    "!wget https://osf.io/download/crgu8/ -O ./test.pairs"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "metadata": {
     "vscode": {
      "languageId": "python"
@@ -64,7 +76,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {
     "vscode": {
      "languageId": "python"
@@ -82,9 +94,6 @@
     "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.scaling as scaling\n",
     "import bioframe"
@@ -100,7 +109,7 @@
    },
    "outputs": [],
    "source": [
-    "pairs_path = './tmp/test.pairs'"
+    "pairs_path = './test.pairs'"
    ]
   },
   {
@@ -151,7 +160,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {
     "vscode": {
      "languageId": "python"
@@ -160,7 +169,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 600x1000 with 2 Axes>"
       ]
@@ -170,10 +179,10 @@
     }
    ],
    "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",
+    "fig = plt.figure(figsize=(6, 10))\n",
+    "gs = matplotlib.gridspec.GridSpec(2, 1, height_ratios=[8, 3])\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",
@@ -205,52 +214,53 @@
     "\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.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.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.xlim(1e1, 1e9)\n",
+    "plt.ylim(-2, 1.1)\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"
+    "plt.yticks(np.arange(-2, 1.1, 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"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "main",
+   "display_name": "test",
    "language": "python",
-   "name": "main"
+   "name": "test"
   },
   "language_info": {
-   "name": "",
-   "version": ""
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 4d87a48a..c3a79622 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -9,24 +9,28 @@ class ParseError(Exception):
     pass
 
 
-# dictionary of allowed automatic opener formats and modes 
-# key is format, value is list with allowed modes
-MODES_TO_FILES_PRESET = {
+# dictionary of allowed modes for each file type: 
+# key: format, 
+# value: list with allowed modes
+PRESET_EXT2MODE = {
     'bam': ['w', 'r'],
     'gz': ['w', 'r', 'a'],
     'lz4': ['w', 'r', 'a'],
 }
 
 # dictionary of automatic opener commands
-# key is tuple from fomat and mode and value is dictionary 
-# with keys tools - tool which we will try to find via shutil and command which will be formatted by thread number
-#dict ('file_format', 'mode'): 'command formatted to set threads number'
-COMMANDS = {
+# key: tuple (file format, mode)
+# value: dictionary with keys tools - 
+#       'tool': name of the tool that the CommandRun will attempt to find via shutil,
+#       'command': command line with the number of threads to be formatted before the execution.
+# In summary:
+# dict ('file_format', 'mode'): ['tool': 'tool_name', 'command': 'command formatted to set threads number']
+PRESET_COMMANDS = {
     ('bam', 'w'): [
         {'tool': 'samtools', 'command': 'samtools view -bS -@ {} -'}
     ],
     ('bam', 'r'): [
-        {'tool': 'samtools', 'command': 'samtools view -h'}
+        {'tool': 'samtools', 'command': 'samtools view -@ {} -h'}
     ],
     ('gz', 'w'): [
         {'tool': 'pbgzip', 'command': 'pbgzip -c -n {}'},
@@ -58,12 +62,18 @@ class ParseError(Exception):
 @dataclass
 class CommandRunResult:
     """
-    CommandRunResult represents the outcome of executing a command, encapsulating the standard input, output, and error streams, along with the mode of operation.
+    CommandRunResult is a simple class that represents the IO command execution.
+    It encapsulates the standard input, output, and error streams, along with the mode of operation.
+
+    Mode of operation dictates the choice of input/output files: 
+        'r' = reading, when output file is disabled,
+        'w' = writing, when the input file is disabled,
+        'a' = appending (input file is disabled).
 
     Attributes:
-        errors (Optional[TextIO]): The standard error stream (stderr) of the process. Can be None if not applicable.
-        output (Optional[TextIO]): The standard output stream (stdout) of the process. Can be None if not applicable.
-        input (Optional[TextIO]): The standard input stream (stdin) of the process. Can be None if not applicable.
+        input (Optional[TextIO]): The standard input stream (stdin) of the process. Can be None.
+        errors (Optional[TextIO]): The standard error stream (stderr) of the process. Can be None.
+        output (Optional[TextIO]): The standard output stream (stdout) of the process. Can be None.
         mode (Optional[Literal['r', 'w', 'a']]): The mode in which the file is opened: 'r' for reading, 'w' for writing, or 'a' for appending.
 
     Properties:
@@ -72,9 +82,9 @@ class CommandRunResult:
             - 'w' or 'a': Returns the input stream (stdin) for writing or appending.
     """
 
+    input: tp.Optional[tp.TextIO]
     errors: tp.Optional[tp.TextIO]
     output: tp.Optional[tp.TextIO]
-    input: tp.Optional[tp.TextIO]
     mode: tp.Optional[tp.Literal['r', 'w', 'a']]
 
     @property
@@ -88,7 +98,7 @@ def outfile(self) -> tp.Optional[tp.TextIO]:
 @dataclass
 class CommandFormatter():
     """
-    A class to manage file opening operations with support for various compression formats.
+    CommandFormatter is a class that manages file opening operations with support for various compression formats.
 
     Attributes:
         mode (str): Mode in which the file is to be opened ('r', 'w', or 'a').
@@ -96,7 +106,7 @@ class CommandFormatter():
         command (Optional[Union[List[str], str]]): Custom command for file processing. For some file formats we have default commands. If empty or None, the class will try to find a suitable command based on the file format and mode.
         If a command is provided, it will be used directly.
         nproc (int): Number of threads for multithreaded tools. Defaults to 1.
-        is_binary (bool): Indicates if the file should be opened in binary mode. Defaults to False.
+        is_binary (bool): Indicates if the file should be opened in binary mode. Default is False.
 
     Methods:
         __call__(): Executes the command or opens the file based on the provided parameters. Return pairtools.lib.fileio.CommandRunResult object
@@ -108,76 +118,105 @@ class CommandFormatter():
     nproc: int=1
     is_binary: bool=False
 
-    #Error textm formatter. If some bash tools is needed but not found, user catch error like SomeTool not found, cannot compress output
-    #This method is used to construct understandable error text
     @staticmethod
-    def form_notfounderror_text(searched_tools: tp.List[str], is_read: bool) -> str:
-        tools_article = 'is' if len(searched_tools) == 1 else 'are'
-        tools_defenition = 'compress output' if is_read else 'decompress input'
-        tools_list = f'{"", "".join(searched_tools[:-1])} and {searched_tools[-1]}' if len(searched_tools) > 1 else searched_tools[0]
-        return f"{tools_list} {tools_article} not found, cannot {tools_defenition}"
+    def format_notfounderror(checked_tools: tp.List[str], mode: bool) -> str:
+        """
+        Format a neat error message, used in case when none tools were found in the system.
+        """
+        text_task = 'read input file' if mode=='r' else 'write input file'
+        if len(checked_tools)==0:
+            raise ValueError('Something went wrong while IO operations. None tools were checked.')
+        elif len(checked_tools)==1:
+            text_verb = 'is'
+            text_tools = checked_tools[0]
+        else:
+            text_verb = 'are'
+            text_tools = f'{"", "".join(checked_tools[:-1])} and {checked_tools[-1]}'
+        return f"{text_tools} {text_verb} not found, cannot {text_task}"
 
     def __post_init__(self):
+        """
+        Post-initialization modification of the command instructions.
+        Adds instructions for binary files, detects file extension, checks and picks the tools available in the system.
+        """
         self.__nocommand = False
+
+        # Add instruction for the binary files:
         if self.is_binary:
             self.file_mode = f'{self.mode}b'
         else:
             self.file_mode = self.mode
 
-        #if we have command, just run it
+        # If the command was provided by the user, simply run it, no urther modifications needed:
         if self.command:
             return
         
-        self.__format = self.path.split('.')[-1]
+        # Get the file extension:
+        self.__extension = self.path.split('.')[-1]
 
-        #if format not in MODES_TO_FILES_PRESET, we will return opened file in given mode
-        if self.__format not in MODES_TO_FILES_PRESET.keys():
+        # If extension is not in the keys of PRESET_EXT2MODE, 
+        # simply return opened file in a given mode
+        if self.__extension not in PRESET_EXT2MODE.keys():
             self.__nocommand = True
             return
         
-        #cannot open given format in given mode
-        if (self.__format, self.mode) not in COMMANDS.keys():
-            raise ValueError(f'{self.__format} can not to be opened in {self.mode}')
+        # If given mode is not applicable to the given extension, raise an error:
+        if (self.__extension, self.mode) not in PRESET_COMMANDS.keys():
+            raise ValueError(f'{self.__extension} can not to be opened in "{self.mode}" mode')
         
-        #iterate over tools. Function calling ends when tool is founded
-        #just forms self.command
+        # Next, iterate over possible tools. When the tool is found, constructs a command.
         checked_tools = []
-        for possible_solution in COMMANDS[(self.__format, self.mode)]:
+        for possible_solution in PRESET_COMMANDS[(self.__extension, self.mode)]:
             if shutil.which(possible_solution['tool']) is None:
                 checked_tools.append(possible_solution['tool'])
                 continue
             self.command = possible_solution['command'].format(str(self.nproc))
             return
 
-        #if we have no return (in iterate over tools), catch an error
-        raise ValueError(self.form_notfounderror_text(checked_tools, self.mode=='r'))
-    
-    def __convert_command(self):
+        # No suitable command was found in the system, raise and format an error message.
+        raise ValueError(self.format_notfounderror(checked_tools, self.mode=='r'))
+
+    def __construct_process(self):
+        """
+        Construct subprocess Popen object for a command, file path and file opening mode.
+        """
+
+        # Split the command, if needed:
         if isinstance(self.command, str):
-            self.__command_to_sp = shlex.split(self.command)
+            command_split = shlex.split(self.command)
         else:
-            self.__command_to_sp = self.command
+            command_split = self.command
 
-    def __form_command(self):
+        # Open the file:
         self.__process_file = open(self.path, self.file_mode)
+
+        # Run Popen:
         if self.mode == 'r':
-            cmd=subprocess.Popen(self.__command_to_sp, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            cmd = subprocess.Popen(command_split, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
         else:
-            cmd=subprocess.Popen(self.__command_to_sp, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            cmd = subprocess.Popen(command_split, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        
         return cmd
     
     def __call__(self) -> CommandRunResult:
-        # Empty path or path '-' means that we just read from stdin or write to stdout (for || case)
+        """
+        Execute the command.
+        """
+
+        # Empty path or path '-' means that we just read from stdin or write to stdout (in case of piping)
         if not self.path or self.path == "-":
-            # we will write at sys.stdout and read from sys.stdin it's strnga but...
+            # sys.stdout and sys.stdin are inverted:
             return CommandRunResult(input=sys.stdout, errors=None, output=sys.stdin, mode=self.mode)
-        # if we have no command, just open file in given mode
-        # nocammand means that there is empty cmd AND we have no format in MODES_TO_FILES_PRESET
+
+        # No command can happen when: 
+        # (1) the provided extension is not in PRESET_EXT2MODE 
+        # and (2) no command was provided by user.
+        # We then simply open file in given mode and do not run any command on it:
         if self.__nocommand:
             self.__process_file = open(self.path, self.file_mode)
             return CommandRunResult(input=self.__process_file, errors=None, output=self.__process_file, mode=self.mode)
-        self.__convert_command()
-        process = self.__form_command()
+
+        process = self.__construct_process()
         return CommandRunResult(input=process.stdin, errors=process.stderr, output=process.stdout, mode=self.mode)
 
 
@@ -187,20 +226,21 @@ def auto_open(path, mode, nproc=1, command=None):
 
     Determines the file format from its extension and selects the appropriate
     command for reading or writing, utilizing available compression or
-    decompression tools. If a specific command is provided, it will be used
-    directly.
+    decompression tools. If user defines an input command, it will be used
+    instead.
 
     Parameters:
-        path (str): Path to the file or '-' for standard input/output.
+        path (str): Path to the file or '-' for standard input/output. Can be None in a piping regime.
         mode (str): File access mode: 'r' (read), 'w' (write), or 'a' (append).
-        nproc (int, optional): Number of threads for multithreaded tools. Defaults to 1.
-        command (str or list, optional): Custom command for file processing. Defaults to None.
+        nproc (int, optional): Number of threads for multithreaded tools. Default is 1.
+        command (str or list, optional): Custom command for file processing. Default is None.
 
     Returns:
         file-like object: A file object ready for reading or writing data.
 
     Raises:
-        ValueError: If the file format is unsupported or the required tool is not found.
+        ValueError: File format detected from extension is not supported.
+        ValueError: Required tool is not found available in the system.
     """
     command = CommandFormatter(mode=mode, path=path, command=command, nproc=nproc)
     result = command()

From 367248668f1bab94b2cd2312ff96664c3401f21d Mon Sep 17 00:00:00 2001
From: Aleksandra Galitsyna <agalitzina@gmail.com>
Date: Thu, 19 Jun 2025 08:41:30 -0400
Subject: [PATCH 13/15] fileio: added bgzip version check; example notebook
 with dedup distances updated, OSF download instead of obscure file name.

---
 doc/examples/duplicate_distance.ipynb | 382 ++++++++++++++------------
 pairtools/lib/fileio.py               | 103 +++----
 2 files changed, 269 insertions(+), 216 deletions(-)

diff --git a/doc/examples/duplicate_distance.ipynb b/doc/examples/duplicate_distance.ipynb
index f12eed7e..30507d9f 100644
--- a/doc/examples/duplicate_distance.ipynb
+++ b/doc/examples/duplicate_distance.ipynb
@@ -16,10 +16,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import numpy as np\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "from pairtools.lib import headerops, fileio\n",
-    "import pandas as pd\n",
+    "from pairtools.lib.pairsio import read_pairs\n",
+    "\n",
     "from scipy.spatial import KDTree # Change to cKDTree for faster performance with scipy <1.6.0\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
     "import matplotlib.pyplot as plt\n",
     "from matplotlib.colors import LogNorm\n",
     "import seaborn as sns"
@@ -27,18 +40,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Read in the pairs file and get the header, take columns from the header\n",
-    "def read_pairs(pairs_file):\n",
-    "    pairs_stream = fileio.auto_open(pairs_file, 'r')\n",
-    "    header, pairs_stream = headerops.get_header(pairs_stream)\n",
-    "    columns = headerops.get_colnames(header)\n",
-    "    df = pd.read_table(pairs_stream, comment=\"#\", header=None, names=columns)\n",
-    "    return df\n",
-    "\n",
     "def dup_dist(df, r, cols=['pos1', 'pos2'], p=1):\n",
     "    # KDtree is a data structure that allows for fast nearest-neighbor lookup\n",
     "    tree = KDTree(df[cols].to_numpy())\n",
@@ -69,22 +74,54 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2025-06-19 08:37:43--  https://osf.io/49qmg/download\n",
+      "Resolving osf.io (osf.io)... 35.190.84.173\n",
+      "Connecting to osf.io (osf.io)|35.190.84.173|:443... connected.\n",
+      "HTTP request sent, awaiting response... 302 FOUND\n",
+      "Location: https://files.de-1.osf.io/v1/resources/638ue/providers/osfstorage/685400f571ee75a245c89bed?action=download&direct&version=1 [following]\n",
+      "--2025-06-19 08:37:43--  https://files.de-1.osf.io/v1/resources/638ue/providers/osfstorage/685400f571ee75a245c89bed?action=download&direct&version=1\n",
+      "Resolving files.de-1.osf.io (files.de-1.osf.io)... 35.186.249.111\n",
+      "Connecting to files.de-1.osf.io (files.de-1.osf.io)|35.186.249.111|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 223185734 (213M) [application/octet-stream]\n",
+      "Saving to: ‘SRR6675327.hg19.sampled.pairs.gz’\n",
+      "\n",
+      "SRR6675327.hg19.sam 100%[===================>] 212.85M  24.9MB/s    in 9.0s    \n",
+      "\n",
+      "2025-06-19 08:37:53 (23.6 MB/s) - ‘SRR6675327.hg19.sampled.pairs.gz’ saved [223185734/223185734]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!wget https://osf.io/49qmg/download -O SRR6675327.hg19.sampled.pairs.gz "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "pairs_df = read_pairs('SRR6675327.hg19.pairs.gz')"
+    "pairs_df, header, chromsizes = read_pairs('SRR6675327.hg19.sampled.pairs.gz')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Remove unnecessary chromosomes and sample 10 mln pairs for faster computation\n",
+    "# Remove unnecessary chromosomes and sample 1 mln pairs for faster computation\n",
     "pairs_df = pairs_df[pairs_df['chrom1'].isin([f'chr{x}' for x in list(range(1, 23))+['X', 'Y']]) & \\\n",
-    "                    pairs_df['chrom2'].isin([f'chr{x}' for x in list(range(1, 23))+['X', 'Y']])].sample(int(1e7))"
+    "                    pairs_df['chrom2'].isin([f'chr{x}' for x in list(range(1, 23))+['X', 'Y']])]"
    ]
   },
   {
@@ -96,19 +133,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
     "dup_dists = calculate_dup_dists(pairs_df,\n",
-    "                                         cols=['pos51', 'pos52'], # Use 5-prime positions of alignment (in this case, stored in the pairs file)\n",
-    "                                         r=50, # Consider pairs with distance less than 50 bp\n",
-    "                                         )"
+    "                                 cols=['pos51', 'pos52'], # Use 5-prime positions of alignment (in this case, stored in the pairs file)\n",
+    "                                 r=50, # Consider pairs with distance less than 50 bp\n",
+    "                                 )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -141,36 +178,36 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>3303</td>\n",
-       "      <td>3302</td>\n",
-       "      <td>0</td>\n",
-       "      <td>0</td>\n",
+       "      <td>372</td>\n",
+       "      <td>373</td>\n",
+       "      <td>4</td>\n",
+       "      <td>10</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>3719</td>\n",
-       "      <td>3720</td>\n",
+       "      <td>553</td>\n",
+       "      <td>554</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>9587</td>\n",
-       "      <td>9586</td>\n",
+       "      <td>642</td>\n",
+       "      <td>643</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>10507</td>\n",
-       "      <td>10508</td>\n",
+       "      <td>717</td>\n",
+       "      <td>718</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>19741</td>\n",
-       "      <td>19740</td>\n",
+       "      <td>1125</td>\n",
+       "      <td>1126</td>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
@@ -179,15 +216,15 @@
        "</div>"
       ],
       "text/plain": [
-       "     id1    id2  dist1  dist2\n",
-       "0   3303   3302      0      0\n",
-       "1   3719   3720      0      0\n",
-       "2   9587   9586      0      0\n",
-       "3  10507  10508      0      0\n",
-       "4  19741  19740      0      0"
+       "    id1   id2  dist1  dist2\n",
+       "0   372   373      4     10\n",
+       "1   553   554      0      0\n",
+       "2   642   643      0      0\n",
+       "3   717   718      0      0\n",
+       "4  1125  1126      0      0"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -199,7 +236,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -210,7 +247,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -284,123 +321,123 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>54050</td>\n",
-       "      <td>6997</td>\n",
-       "      <td>7417</td>\n",
-       "      <td>5254</td>\n",
-       "      <td>6224</td>\n",
-       "      <td>5844</td>\n",
-       "      <td>5417</td>\n",
-       "      <td>4896</td>\n",
-       "      <td>5075</td>\n",
-       "      <td>4846</td>\n",
+       "      <td>53000</td>\n",
+       "      <td>7681</td>\n",
+       "      <td>8992</td>\n",
+       "      <td>5409</td>\n",
+       "      <td>5440</td>\n",
+       "      <td>5144</td>\n",
+       "      <td>5532</td>\n",
+       "      <td>5167</td>\n",
+       "      <td>5307</td>\n",
+       "      <td>5389</td>\n",
        "      <td>...</td>\n",
-       "      <td>3342</td>\n",
+       "      <td>3727</td>\n",
+       "      <td>3728</td>\n",
+       "      <td>3038</td>\n",
+       "      <td>3117</td>\n",
+       "      <td>3496</td>\n",
+       "      <td>2773</td>\n",
+       "      <td>3045</td>\n",
+       "      <td>3050</td>\n",
+       "      <td>2835</td>\n",
        "      <td>3137</td>\n",
-       "      <td>2772</td>\n",
-       "      <td>2612</td>\n",
-       "      <td>2646</td>\n",
-       "      <td>2567</td>\n",
-       "      <td>2879</td>\n",
-       "      <td>2792</td>\n",
-       "      <td>2594</td>\n",
-       "      <td>2602</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>18570</td>\n",
-       "      <td>3684</td>\n",
-       "      <td>3909</td>\n",
-       "      <td>2105</td>\n",
-       "      <td>2599</td>\n",
-       "      <td>2601</td>\n",
-       "      <td>2270</td>\n",
-       "      <td>2081</td>\n",
-       "      <td>2407</td>\n",
-       "      <td>2438</td>\n",
+       "      <td>18218</td>\n",
+       "      <td>3926</td>\n",
+       "      <td>3582</td>\n",
+       "      <td>2474</td>\n",
+       "      <td>2392</td>\n",
+       "      <td>2463</td>\n",
+       "      <td>2699</td>\n",
+       "      <td>2145</td>\n",
+       "      <td>2370</td>\n",
+       "      <td>2393</td>\n",
        "      <td>...</td>\n",
-       "      <td>1748</td>\n",
-       "      <td>1361</td>\n",
-       "      <td>1168</td>\n",
-       "      <td>1198</td>\n",
-       "      <td>1247</td>\n",
-       "      <td>1094</td>\n",
-       "      <td>1434</td>\n",
-       "      <td>1231</td>\n",
-       "      <td>1197</td>\n",
-       "      <td>1120</td>\n",
+       "      <td>1608</td>\n",
+       "      <td>1574</td>\n",
+       "      <td>1285</td>\n",
+       "      <td>1230</td>\n",
+       "      <td>1354</td>\n",
+       "      <td>1339</td>\n",
+       "      <td>1267</td>\n",
+       "      <td>1029</td>\n",
+       "      <td>1134</td>\n",
+       "      <td>1398</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>11672</td>\n",
-       "      <td>2980</td>\n",
-       "      <td>1716</td>\n",
-       "      <td>1665</td>\n",
-       "      <td>1745</td>\n",
-       "      <td>1652</td>\n",
-       "      <td>1529</td>\n",
-       "      <td>1572</td>\n",
-       "      <td>1583</td>\n",
-       "      <td>1795</td>\n",
+       "      <td>12700</td>\n",
+       "      <td>2835</td>\n",
+       "      <td>1715</td>\n",
+       "      <td>1626</td>\n",
+       "      <td>1740</td>\n",
+       "      <td>1670</td>\n",
+       "      <td>1938</td>\n",
+       "      <td>1643</td>\n",
+       "      <td>1486</td>\n",
+       "      <td>1600</td>\n",
        "      <td>...</td>\n",
-       "      <td>1562</td>\n",
-       "      <td>1324</td>\n",
-       "      <td>1120</td>\n",
-       "      <td>1077</td>\n",
-       "      <td>1025</td>\n",
-       "      <td>967</td>\n",
-       "      <td>1263</td>\n",
-       "      <td>1051</td>\n",
-       "      <td>1047</td>\n",
-       "      <td>998</td>\n",
+       "      <td>1487</td>\n",
+       "      <td>1473</td>\n",
+       "      <td>1094</td>\n",
+       "      <td>1008</td>\n",
+       "      <td>1309</td>\n",
+       "      <td>1064</td>\n",
+       "      <td>1150</td>\n",
+       "      <td>989</td>\n",
+       "      <td>1002</td>\n",
+       "      <td>1203</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>12716</td>\n",
-       "      <td>2941</td>\n",
-       "      <td>1878</td>\n",
-       "      <td>1764</td>\n",
-       "      <td>1731</td>\n",
-       "      <td>1827</td>\n",
-       "      <td>1627</td>\n",
-       "      <td>1593</td>\n",
-       "      <td>1768</td>\n",
-       "      <td>1814</td>\n",
+       "      <td>13393</td>\n",
+       "      <td>2862</td>\n",
+       "      <td>1838</td>\n",
+       "      <td>1556</td>\n",
+       "      <td>1729</td>\n",
+       "      <td>1686</td>\n",
+       "      <td>1726</td>\n",
+       "      <td>1649</td>\n",
+       "      <td>1536</td>\n",
+       "      <td>1551</td>\n",
        "      <td>...</td>\n",
-       "      <td>1573</td>\n",
-       "      <td>1374</td>\n",
-       "      <td>1123</td>\n",
-       "      <td>1144</td>\n",
-       "      <td>1092</td>\n",
-       "      <td>995</td>\n",
-       "      <td>1435</td>\n",
-       "      <td>1077</td>\n",
-       "      <td>1089</td>\n",
-       "      <td>1020</td>\n",
+       "      <td>1386</td>\n",
+       "      <td>1378</td>\n",
+       "      <td>994</td>\n",
+       "      <td>1022</td>\n",
+       "      <td>1237</td>\n",
+       "      <td>1088</td>\n",
+       "      <td>1142</td>\n",
+       "      <td>1059</td>\n",
+       "      <td>1023</td>\n",
+       "      <td>1217</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>12715</td>\n",
-       "      <td>3070</td>\n",
-       "      <td>2351</td>\n",
-       "      <td>1997</td>\n",
-       "      <td>1956</td>\n",
-       "      <td>1969</td>\n",
-       "      <td>2010</td>\n",
-       "      <td>1835</td>\n",
-       "      <td>1784</td>\n",
-       "      <td>2090</td>\n",
+       "      <td>13460</td>\n",
+       "      <td>3040</td>\n",
+       "      <td>2063</td>\n",
+       "      <td>2060</td>\n",
+       "      <td>2139</td>\n",
+       "      <td>1878</td>\n",
+       "      <td>2056</td>\n",
+       "      <td>1891</td>\n",
+       "      <td>1832</td>\n",
+       "      <td>1903</td>\n",
        "      <td>...</td>\n",
-       "      <td>1569</td>\n",
-       "      <td>1429</td>\n",
-       "      <td>1131</td>\n",
-       "      <td>1256</td>\n",
-       "      <td>1178</td>\n",
-       "      <td>1083</td>\n",
-       "      <td>1383</td>\n",
-       "      <td>1132</td>\n",
-       "      <td>1138</td>\n",
-       "      <td>1069</td>\n",
+       "      <td>1600</td>\n",
+       "      <td>1582</td>\n",
+       "      <td>1287</td>\n",
+       "      <td>1277</td>\n",
+       "      <td>1428</td>\n",
+       "      <td>1282</td>\n",
+       "      <td>1322</td>\n",
+       "      <td>1179</td>\n",
+       "      <td>1174</td>\n",
+       "      <td>1326</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -410,24 +447,24 @@
       "text/plain": [
        "dist2     0     1     2     3     4     5     6     7     8     9   ...    41  \\\n",
        "dist1                                                               ...         \n",
-       "0      54050  6997  7417  5254  6224  5844  5417  4896  5075  4846  ...  3342   \n",
-       "1      18570  3684  3909  2105  2599  2601  2270  2081  2407  2438  ...  1748   \n",
-       "2      11672  2980  1716  1665  1745  1652  1529  1572  1583  1795  ...  1562   \n",
-       "3      12716  2941  1878  1764  1731  1827  1627  1593  1768  1814  ...  1573   \n",
-       "4      12715  3070  2351  1997  1956  1969  2010  1835  1784  2090  ...  1569   \n",
+       "0      53000  7681  8992  5409  5440  5144  5532  5167  5307  5389  ...  3727   \n",
+       "1      18218  3926  3582  2474  2392  2463  2699  2145  2370  2393  ...  1608   \n",
+       "2      12700  2835  1715  1626  1740  1670  1938  1643  1486  1600  ...  1487   \n",
+       "3      13393  2862  1838  1556  1729  1686  1726  1649  1536  1551  ...  1386   \n",
+       "4      13460  3040  2063  2060  2139  1878  2056  1891  1832  1903  ...  1600   \n",
        "\n",
        "dist2    42    43    44    45    46    47    48    49    50  \n",
        "dist1                                                        \n",
-       "0      3137  2772  2612  2646  2567  2879  2792  2594  2602  \n",
-       "1      1361  1168  1198  1247  1094  1434  1231  1197  1120  \n",
-       "2      1324  1120  1077  1025   967  1263  1051  1047   998  \n",
-       "3      1374  1123  1144  1092   995  1435  1077  1089  1020  \n",
-       "4      1429  1131  1256  1178  1083  1383  1132  1138  1069  \n",
+       "0      3728  3038  3117  3496  2773  3045  3050  2835  3137  \n",
+       "1      1574  1285  1230  1354  1339  1267  1029  1134  1398  \n",
+       "2      1473  1094  1008  1309  1064  1150   989  1002  1203  \n",
+       "3      1378   994  1022  1237  1088  1142  1059  1023  1217  \n",
+       "4      1582  1287  1277  1428  1282  1322  1179  1174  1326  \n",
        "\n",
        "[5 rows x 51 columns]"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -446,12 +483,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -490,12 +527,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGwCAYAAAD16iy9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABfZElEQVR4nO3deVhU5dsH8O8ZlgERUFQEEtByxQUXyLUEc5sM11xTUdtMzK3MqMwlFZdcMtx/rlnpawrapqIpaqUBSmqSKyYpRJqy6oDMef8wJ0fWmXlgZpjvx+tcl3PmnHvuOQxw82xHkmVZBhEREZEAClMnQERERJUHCwsiIiIShoUFERERCcPCgoiIiIRhYUFERETCsLAgIiIiYVhYEBERkTC2pk6gvGk0Gty4cQPOzs6QJMnU6RARkZ5kWUZWVha8vLygUJTP38P37t1DXl6ekFj29vZwcHAQEssSVfrC4saNG/D29jZ1GkREZKSUlBTUqVNHeNx79+7B0dEJgEZIPA8PDyQnJ1ttcVHpCwtnZ+cH/1HUgiQZV+n+7N1CQEYPZOYohcRp0PqWkDgAIIv5noKkFNcyJN8TszCs5CCwtapAUByNuEVvNfli4tjWFPcjQZMl5kIpnG2ExAEAyUbMX7sFmYIuOAAbFzshcdQp4nIy8kellkIp5jOedf8+/A/F/ffzXLAHLRUaKGxrAzD2Z4WMtLQ05OXlsbCorB52f0iSwujCoqpCzA8AACgQFMvZTtyXUFRhobAT90tcc1/MDyaROcmiWmJFFhaCQtkJ/DwVCLrmNnYCCwtbQYWFnbivnY29mGt+z1ZcTsIKC4HXCUC5d2dLkIz+PSGL+kFqwSp9YUFERFQWkiQJKF44lo+FBREREVhYiMLppkRERCSMRRQWK1euRL169eDg4IA2bdrg6NGjpk6JiIgqGUnQPwAIDAyEn58fVqxYYeJ3VfHMvitk+/btmDRpElauXImOHTtizZo1UKlUOHfuHHx8fEydHhERVRIiu0Li4uLg4uJifFIWyOxbLJYsWYKXX34Zr7zyCpo0aYJly5bB29sbq1atKvJ4tVqNzMxMnY2IiIgqhlkXFnl5eUhISED37t119nfv3h0//fRTkedERETA1dVVu3FxLCIiKguFJAnZrJ1ZFxY3b95EQUEBateurbO/du3aSEtLK/Kc8PBwZGRkaLeUlJSKSJWIiCycyDEW1szsx1gAhRdFkWW52H4wpVIJpVLMqpZERESkH7MuLGrWrAkbG5tCrRPp6emFWjGIiIiMoRAweFNmi4V5d4XY29ujTZs2iImJ0dkfExODDh06mCgrIiKqjB7OCjF2s3Zm3WIBAFOmTMGIESMQEBCA9u3bY+3atbh27RrGjh1r6tSIiIjoMWZfWAwePBi3bt3C7NmzkZqaimbNmuG7776Dr6+vqVMjIqJKRCFg8CW7QiygsACAcePGYdy4caZOg4iIKjHeK0QMiygsiIiIypskweh1KHjTdCsqLN7w6gilws6oGL4v5gnKBpCqOIiJ06ynkDgAINnZC4kjF9wXEgcAkJ0lJIzkJbDrLMf8VnOVM24LiSP5NBASBwCgzhUTx7GqmDgi5d0TF0vQ+7NLvSokDgBI1d3FBHKoIiRMQU4uEPOzkFhU/qymsCAiIiqJiK4QLpDFwoKIiAjAg8GbCqMLAxYWZr2OBREREVkWtlgQERGBXSGisLAgIiIChNxEjIWFBXSFHDlyBCEhIfDy8oIkSYiOjjZ1SkRERFQMsy8scnJy4O/vj8jISFOnQkRElZhCkoRs1s7su0JUKhVUKpWp0yAiokqOYyzEMPvCQl9qtRpqtVr7ODPT/BYzIiIiqqzMvitEXxEREXB1ddVu3t7epk6JiIgswMN1LIzdrF2lKyzCw8ORkZGh3VJSUkydEhERWYCHXSHGbgAQGBgIPz8/rFixwsTvquJVuq4QpVIJpVJp6jSIiMjCiFx5My4uDi4uLsYnZYEqXYsFERERmY7Zt1hkZ2fj0qVL2sfJyclITEyEm5sbfHx8TJgZERFVJhIUkCTj/t6WZFlQNpbL7AuL+Ph4BAcHax9PmTIFABAaGopNmzaZKCsiIqpsuPKmGGZfWAQFBUFmBUhERGQRzL6wICIiqghCVs7kypssLIiIiB4wvisE7AqxnsLCL98Wjgrj3q6ikbjFthRtewiJI9k7CokDAPK9HCFxFHbipvtq7qQJiaOo7iUkDgBITq5C4oi63gCgSb0oJI7Cp5mQOAAAUe9PIXDyWsF9MXEEft9JtvZC4micawqJAwAKN0HfL7JGSBibrGwhcahiWE1hQUREVBIRXSEyu0JYWBAREQGcFSIKF8giIiIiYdhiQUREBHaFiMLCgoiICA/mcxjfFUJm3RUSERGBwMBAODs7w93dHX379sX58+dNnRYREVVCD1ssjN2snVkXFrGxsQgLC8Px48cRExOD+/fvo3v37sjJETdNj4iIiMQx666QvXv36jzeuHEj3N3dkZCQgGeffbbIc9RqNdRqtfZxZmZmueZIRESVA2eFiGHWLRaPy8jIAAC4ubkVe0xERARcXV21m7e3uEWtiIio8lI8uL+p0Zu1s5jCQpZlTJkyBZ06dUKzZsWvDhgeHo6MjAztlpKSUoFZEhERWTez7gp51Pjx43H69GkcO3asxOOUSiWUSnFLShMRkXWQJAmSkYMvjT2/MrCIwuLNN9/Enj17cOTIEdSpU8fU6RARUSUkoitDZleIeRcWsizjzTffRFRUFA4fPox69eqZOiUiIiIqgVkXFmFhYfjiiy+we/duODs7Iy3twZ0uXV1d4ego7u6CRERE7AoRw6wHb65atQoZGRkICgqCp6endtu+fbupUyMiokpGEvTP2pl1i4Usy6ZOgYiIiPRg1oUFERFRRZEEDN7UsMXCegoLtQQojP16i2xBUQtalrxKNTFxAABicpI1GiFxAEByriEslihywX0xgWzsxMQBAAcnIWEkSVzvqOZulpA4kqu7kDgPggl6fwKvE2wE/RhWiMtJFvW1c3QWEkfo9S7pZTjGQgirKSyIiIhKImK6KVfeNPPBm0RERGRZWFgQERFB7L1CAgMD4efnhxUrVpj4XVU8doUQEREBkP7djI0BAHFxcXBxcTEymmViiwUREREJY9aFxapVq9CiRQu4uLjAxcUF7du3x/fff2/qtIiIqBJSSJKQzdqZdWFRp04dzJ8/H/Hx8YiPj0eXLl3Qp08f/Pbbb6ZOjYiIKhmuvCmGWY+xCAkJ0Xk8d+5crFq1CsePH0fTpk1NlBUREREVx6wLi0cVFBRgx44dyMnJQfv27Ys9Tq1WQ61Wax9nZmZWRHpERGThuI6FGGZfWJw5cwbt27fHvXv3ULVqVURFRcHPz6/Y4yMiIjBr1qwKzJCIiCoDrrwphlmPsQCARo0aITExEcePH8cbb7yB0NBQnDt3rtjjw8PDkZGRod1SUlIqMFsiIiLrZvYtFvb29qhfvz4AICAgAHFxcfjkk0+wZs2aIo9XKpVQKpUVmSIREVUC7AoRw+wLi8fJsqwzhoKIiEgEEbM6OCvEzAuL9957DyqVCt7e3sjKysK2bdtw+PBh7N2719SpERFRJaOA8eMDzH58QQUw68Lir7/+wogRI5CamgpXV1e0aNECe/fuRbdu3UydGhERERXBrAuL9evXmzoFIiKyFpKAWR3sCTHvwoKIiKiicPCmGOwOIiIiImHYYqEPgbNR5KzbZhUHAFBwX0gYyaWGkDgAIOdkiIlTxVlIHACQcsR828iCrjcAIO2qkDAaB3HXSc7+R0wgG4E/pmSNmDgCv3ay0klMnGyBPws0Yq6T5vYNIXEKsnOFxCkNZ4WIwcKCiIgInBUiCq8BERERCcMWCyIiInDwpigsLIiIiMCbkInCrhAiIiISxqIKi4iICEiShEmTJpk6FSIiqmQUgjZrZzFdIXFxcVi7di1atGhh6lSIiKgS4nRTMSyiuMrOzsZLL72EdevWoXr16iUeq1arkZmZqbMRERGV5uHgTWM3a2cRhUVYWBh69eqFrl27lnpsREQEXF1dtZu3t3cFZEhERESABRQW27Ztw8mTJxEREVGm48PDw5GRkaHdUlJSyjlDIiKqDDjGQgyzHmORkpKCiRMnYv/+/XBwcCjTOUqlEkqlspwzIyKiyoZjLMQw68IiISEB6enpaNOmjXZfQUEBjhw5gsjISKjVatjY2JgwQyIiInqUWRcWzz33HM6cOaOzb/To0WjcuDGmTZvGooKIiIThyptimHVh4ezsjGbNmunsc3JyQo0aNQrtJyIiMhbLAuNxnAkREREJY9YtFkU5fPiwqVMgIqJKSCFJUBh5rw9jz68MLK6wICIiKg8ipouyG8CKCgs7+cFmFI1GSC4AIFX3EBNIYE5QCPqWkMR9a0mCcpJc3IXEESrvnrBQcvW7QuJILjWFxAEg7PMkVakmJA4AQJ0jLpYoNoJ+DDs6i4kDADZ2QsIoBH3fKRRm+HWjYllNYUFERFQSrmMhBgsLIiIisCtEFBYWREREYIuFKCyuiIiISBi2WBAREYFdIaKY9TWYOXMmJEnS2Tw8BM2mICIiesTDJb2N3aydWRcWANC0aVOkpqZqt8fvHUJERGRuAgMD4efnhxUrVpg6lQpn9l0htra2bKUgIqJyJ8H4e4U8PD8uLg4uLi5GRrNMZt9icfHiRXh5eaFevXoYMmQIrly5UuLxarUamZmZOhsREVFp2BUihlkXFm3btsWWLVuwb98+rFu3DmlpaejQoQNu3bpV7DkRERFwdXXVbt7e3hWYMRERkXUz68JCpVJhwIABaN68Obp27Ypvv/0WALB58+ZizwkPD0dGRoZ2S0lJqah0iYjIgikEbdbO7MdYPMrJyQnNmzfHxYsXiz1GqVRCqVRWYFZERFQ5GL9AlvGjNCyfRRVXarUaSUlJ8PT0NHUqREREVASzLizefvttxMbGIjk5GSdOnMCLL76IzMxMhIaGmjo1IiKqZNgVIoZZd4X8+eefGDp0KG7evIlatWqhXbt2OH78OHx9fU2dGhERVTIip5taM7MuLLZt22bqFIiIyEqImC7K6aZstSEiIiKBzLrFgoiIqKLwJmRiWE1hYQsBb7Z6dQGZ/MvW/KbESnb2YgJpNGLiAJBt7ITEkewdhcQBAAiKJRXkC4kDAAV3UoXEkSSBPxYFfcYlewchcQAAgj7jmox0IXEAQFHFVUwgQd8rACDZirlOkqOzkDgKuywhcUrDMRZisLgiIiIiYVhYEBERwTrvFbJ582btqtYA8M4776BatWro0KED/vjjD4NisrAgIiKCda5jMW/ePDg6Puje/fnnnxEZGYmFCxeiZs2amDx5skExrWaMBREREelKSUlB/fr1AQDR0dF48cUX8dprr6Fjx44ICgoyKKalFVdERETlQhK0WZKqVatq7xi+f/9+dO3aFQDg4OCAu3fvGhTT7AuL69evY/jw4ahRowaqVKmCli1bIiEhwdRpERFRJWONYyy6deuGV155Ba+88gouXLiAXr16AQB+++031K1b16CYZl1Y3L59Gx07doSdnR2+//57nDt3DosXL0a1atVMnRoREZHFW7FiBdq3b4+///4bO3fuRI0aNQAACQkJGDp0qEExzXqMxYIFC+Dt7Y2NGzdq95VWQanVaqjVau3jzMzM8kqPiIgqEYX8YDM2hiWpVq0aIiMjC+2fNWuWwTHNusViz549CAgIwMCBA+Hu7o5WrVph3bp1JZ4TEREBV1dX7ebt7V1B2RIRkSWTYPyMEMvqCHng6NGjGD58ODp06IDr168DAD777DMcO3bMoHhmXVhcuXIFq1atQoMGDbBv3z6MHTsWEyZMwJYtW4o9Jzw8HBkZGdotJSWlAjMmIiJLZY2DN3fu3IkePXrA0dERJ0+e1Lb4Z2VlYd68eQbFNOvCQqPRoHXr1pg3bx5atWqF119/Ha+++ipWrVpV7DlKpRIuLi46GxERERU2Z84crF69GuvWrYOd3X/Lwnfo0AEnT540KKZZFxaenp7w8/PT2dekSRNcu3bNRBkREVFlZY0LZJ0/fx7PPvtsof0uLi64c+eOQTHN+hp07NgR58+f19l34cIF+Pr6migjIiKqrKxxuqmnpycuXbpUaP+xY8fw5JNPGhTTrAuLyZMn4/jx45g3bx4uXbqEL774AmvXrkVYWJipUyMiIrJ4r7/+OiZOnIgTJ05AkiTcuHEDn3/+Od5++22MGzfOoJhmPd00MDAQUVFRCA8Px+zZs1GvXj0sW7YML730kqlTIyKiSsYab5v+zjvvICMjA8HBwbh37x6effZZKJVKvP322xg/frxBMc26sACAF154AS+88IKp0yAiokpOxBgJs+4GKMbcuXPx/vvv49y5c9BoNPDz80PVqlUNjmeJ14CIiIgEGDNmDLKyslClShUEBATg6aefRtWqVZGTk4MxY8YYFNPsWyzMyiMrehotz7CbuzxOcnIVEgcAYGNX+jFlIDk6CIkDAMjJEBfL3MgacbEEfe1kQZ9LsyXqM17VTUgcoQryxcWyF/M9LN/NEhQnW0ic0ljjypubN2/G/Pnz4ezsrLP/7t272LJlCzZs2KB3TBYWREREsK4xFpmZmZBlGbIsIysrCw4O/xWTBQUF+O677+Du7m5QbBYWREREVqZatWqQJAmSJKFhw4aFnpckyeD7hbCwICIignUN3jx06BBkWUaXLl2wc+dOuLn9171nb28PX19feHl5GRSbhQURERGsq7Do3LkzACA5ORne3t5QKMRlrldhkZGRgaioKBw9ehRXr15Fbm4uatWqhVatWqFHjx7o0KGDsMSIiIgqkiRg8KZkYYM3H65knZubi2vXriEvL0/n+RYtWugds0wlSmpqKl599VV4enpi9uzZyMnJQcuWLfHcc8+hTp06OHToELp16wY/Pz9s375d7yRKUrduXW0/0KMbV98kIiIyzt9//40XXngBzs7OaNq0KVq1aqWzGaJMLRb+/v4YOXIkfvnlFzRr1qzIY+7evYvo6GgsWbIEKSkpePvttw1K6HFxcXEoKCjQPj579iy6deuGgQMHColPREQEWNeskIcmTZqE27dv4/jx4wgODkZUVBT++usvzJkzB4sXLzYoZpkKi99++w21atUq8RhHR0cMHToUQ4cOxd9//21QMkV5/HXnz5+Pp556Sts/REREJII1jbF46IcffsDu3bsRGBgIhUIBX19fdOvWDS4uLoiIiECvXr30jlmma1BaUWHs8WWVl5eHrVu3YsyYMZCkoutCtVqNzMxMnY2IiIgKy8nJ0a5X4ebmpm0YaN68OU6ePGlQTIOKq/Pnz2P8+PF47rnn0LVrV4wfP77Q7c3LQ3R0NO7cuYNRo0YVe0xERARcXV21m7e3d7nnRURElk8haLMkjRo10v7+btmyJdasWYPr169j9erV8PT0NCim3tfgq6++QrNmzZCQkAB/f3+0aNECJ0+eRLNmzbBjxw6Dkiir9evXQ6VSlTi3Njw8HBkZGdotJSWlXHMiIqLKQZLFbJZk0qRJSE1NBQDMmDEDe/fuhY+PD5YvX4558+YZFFPvdSzeeecd7W3MHzVjxgxMmzat3AZV/vHHHzhw4AB27dpV4nFKpRJKpbJcciAiIqpMXnrpJe3/W7VqhatXr+L333+Hj48PatasaVBMvVss0tLSMHLkyEL7hw8fjrS0NIOSKIuNGzfC3d3doIEkREREpbHGrpDHValSBa1btza4qAAMuAZBQUE4evRoof3Hjh3DM888Y3AiJdFoNNi4cSNCQ0Nha8vFQomISDxrLCxefPFFzJ8/v9D+RYsWGdwDofdv6d69e2PatGlISEhAu3btAADHjx/Hjh07MGvWLOzZs0fnWBEOHDiAa9euGXxveCIiotJY423TY2NjMWPGjEL7e/bsiY8//tigmHoXFuPGjQMArFy5EitXrizyOeDBndEeXdjKGN27d4csW9hXi4iIyMxlZ2fD3t6+0H47OzuDl2vQu9VGo9GUaRNVVBAREVUESdBmSZo1a1bkrTi2bdsGPz8/g2JywAIRERGsc+XN6dOnY8CAAbh8+TK6dOkCADh48CC+/PJLg5eQMKiwOHjwIJYuXYqkpCRIkoTGjRtj0qRJ6Nq1q0FJVATNv5tR7t0TkMm/7quFhJHv5QiJI5KkLH6dEX3Jd7PEBBJ4S2Dczyv9mLLQCGzVyxfzeYLCRkwcAHL2bSFxpKrVhcQBADnzprBYoojq5NXcETcrT1HNQ1AgMd93cl6ukDhUWO/evREdHY158+bhq6++gqOjI1q0aIEDBw4YfOsMvQuLyMhITJ48GS+++CImTpwI4MHgzeeffx5LlizB+PHjDUqEiIjIlKxx8CYA9OrVS+hSDnoXFhEREVi6dKlOATFhwgR07NgRc+fOZWFBREQWy9LGSJgjvdupMjMz0bNnz0L7u3fvzht+ERERmTk3NzfcvPmgW7B69epwc3MrdjOEQetYREVFYerUqTr7d+/ejZCQEIOSICIiMjUFZCiMHPVi7PkVYenSpXB2dgYALFu2THj8MhUWy5cv1/6/SZMmmDt3Lg4fPoz27dsDeDDG4scff8Rbb70lPEEiIqKKYC1jLEJDQ4v8vyhlKiyWLl2q87h69eo4d+4czp07p91XrVo1bNiwAR988IGw5O7fv4+ZM2fi888/R1paGjw9PTFq1Ch88MEHUIgc5U9ERGQl9Bm24OLionf8MhUWycnJegcWYcGCBVi9ejU2b96Mpk2bIj4+HqNHj4arq6t2RgoREZEI1rKORbVq1SBJJQ9TlWXZ4BW0zXqBrJ9//hl9+vTRToOpW7cuvvzyS8THxxd7jlqthlr935x+DiglIqKyELFypiXMKjl06FC5xi9TYTF//ny8+eabcHJyKvXYEydO4ObNm0LmxHbq1AmrV6/GhQsX0LBhQ/z66684duxYiYNNIiIiMGvWLKNfm4iIrItClqEw8r5Uxp5fEQxd+KqsylRYnDt3Dr6+vhg4cCB69+6NgIAA1KpVC8CDcRDnzp3DsWPHsHXrVqSmpmLLli1Ckps2bRoyMjLQuHFj2NjYoKCgAHPnzsXQoUOLPSc8PBxTpkzRPs7MzIS3t7eQfIiIiCqb27dvY/369drVtJs0aYLRo0cbPN20TN1BW7ZswQ8//ACNRoOXXnoJHh4esLe3h7OzM5RKJVq1aoUNGzZg1KhR+P333/HMM88YlMzjtm/fjq1bt+KLL77AyZMnsXnzZnz88cfYvHlzsecolUq4uLjobERERKVRCNosSWxsLOrWrYvly5fj9u3b+Oeff7B8+XLUq1cPsbGxBsUs8xiLFi1aYM2aNVi9ejVOnz6Nq1ev4u7du6hZsyZatmyJmjVrGpRASaZOnYp3330XQ4YMAQA0b94cf/zxByIiIspligwREVkvaxlj8aiwsDAMHjwYq1atgo3Ng3sFFRQUYNy4cQgLC8PZs2f1jqn34E1JkuDv7w9/f3+9X0xfubm5haaV2tjYQKMx+nZiREREVu/y5cvYuXOntqgAHvyenTJlisHDGsx6VkhISAjmzp0LHx8fNG3aFKdOncKSJUswZswYU6dGRESVjLWsvPmo1q1bIykpCY0aNdLZn5SUhJYtWxoU06wLi08//RTTp0/HuHHjkJ6eDi8vL7z++uv48MMPTZ0aERFVMtay8uajJkyYgIkTJ+LSpUto164dgAeraa9YsQLz58/H6dOntce2aNGiTDHNurBwdnbGsmXLymUtcyIiosokNzcXTZo0wcCBA/Hxxx+X6ZyHsyzfeeedIp+TJEnvxbLMurAgIiKqKBJkSEZ2ZRh7vjHmzp2Ltm3b6nVOeaysbTWFhebfzSgC708i38sREkdydBYSRyTNnTRTp1BYwX1hoYR97ZyqCYkDQNj7k+wdhMQBADiUvqBeWcj384TEAQDYCPqRJzAnqYqrmECZ6WLiAJBFfZ7sxHwGoKiYX1USjJ8uaqpZIRcvXsTvv/+OkJAQvWZy+Pr6Cs9F2Ffr8uXLePXVV/HDDz+ICklERFTpHTlyBIsWLUJCQgJSU1MRFRWFvn376hyzcuVKLFq0CKmpqWjatCmWLVums2bU22+/jUWLFuGnn37S67VLm/kxcuRIveIBAguL7OxsgxfTICIiMjWRNyF7/D5VSqUSSqWyyHNycnLg7++P0aNHY8CAAYWe3759OyZNmoSVK1eiY8eOWLNmDVQqFc6dOwcfHx/s3r0bDRs2RMOGDfUuLB6/oWd+fj5yc3Nhb2+PKlWqlG9hsXz58hKfv379ut4vTkREZC5EjrF4/FYSM2bMwMyZM4s8R6VSQaVSFRtzyZIlePnll/HKK68AAJYtW4Z9+/Zh1apViIiIwPHjx7Ft2zbs2LED2dnZyM/Ph4uLS5lmUN6+fbvQvosXL+KNN97A1KlTSz2/KGUuLCZNmgRPT0/Y29sX+XxensB+UCIiogomssUiJSVF55YSxbVWlCYvLw8JCQl49913dfZ3795d2zoRERGBiIgIAMCmTZtw9uxZo5ZlaNCgAebPn4/hw4fj999/1/v8MhcWvr6+WLBgAQYNGlTk84mJiWjTpo3eCRAREVU2ou5VdfPmTRQUFKB27do6+2vXro20tPIbKG9jY4MbN24YdG6ZC4s2bdogISGh2MLi4VxX0bKysjB9+nRERUUhPT0drVq1wieffILAwEDhr0VERNbLnKebSpLufJOHa0s8btSoUXrF3bNnT6G4qampiIyMRMeOHfXOE9CjsJg9ezZyc3OLfd7Pz69c5sO+8sorOHv2LD777DN4eXlh69at6Nq1K86dO4cnnnhC+OsREZF1MsclvWvWrAkbG5tCrRPp6emFWjEM8fjsE0mSUKtWLXTp0gWLFy82KGaZCws/P78Sn7ezsxM+H/bu3bvYuXMndu/ejWeffRYAMHPmTERHR2PVqlWYM2eO0NcjIiIyJ/b29mjTpg1iYmLQr18/7f6YmBj06dPH6PjlcVNPs14g6/79+ygoKICDg+6iPY6Ojjh27FiR56jVaqjVau3jx6f8EBERFUUhPdiMjaGv7OxsXLp0Sfs4OTkZiYmJcHNzg4+PD6ZMmYIRI0YgICAA7du3x9q1a3Ht2jWMHTvWuGTLiVkXFs7Ozmjfvj0++ugjNGnSBLVr18aXX36JEydOoEGDBkWeExERgVmzZlVwpkREZOlMNcYiPj4ewcHB2sdTpkwBAISGhmLTpk0YPHgwbt26hdmzZyM1NRXNmjXDd999Z3AvwcP4ZbFkyRK945t1YQEAn332GcaMGYMnnngCNjY2aN26NYYNG4aTJ08WeXx4eLjORcvMzCw0n5iIiMhcBAUFlTr5Ydy4cRg3bpyQ1zt16pTO44SEBBQUFGhvnX7hwgXY2NgYPNPT7AuLp556CrGxscjJyUFmZiY8PT0xePBg1KtXr8jjS1rdjIiIqDgi17EwZ4cOHdL+f8mSJXB2dsbmzZtRvXp1AA8WzRo9erTOkuH6MOoa3Lt3z5jT9eLk5ARPT0/cvn0b+/btEzJohYiI6CFJkoVslmTx4sWIiIjQFhUAUL16dcyZM8fgWSF6FxYajQYfffQRnnjiCVStWhVXrlwBAEyfPh3r1683KImS7Nu3D3v37kVycjJiYmIQHByMRo0aYfTo0cJfi4iISITAwED4+flhxYoVpk6lRJmZmfjrr78K7U9PT0dWVpZBMfUuLObMmYNNmzZh4cKFOst7N2/eHP/73/8MSqIkGRkZCAsLQ+PGjTFy5Eh06tQJ+/fvh52dnfDXIiIi66WQZCEbAMTFxeHcuXMICwsz8bsqWb9+/TB69Gh89dVX+PPPP/Hnn3/iq6++wssvv4z+/fsbFFPvMRZbtmzB2rVr8dxzz+lMdWnRooVBa4qXZtCgQcWu9klERCSK9O9mbAxLsnr1arz99tsYPnw48vPzAQC2trZ4+eWXsWjRIoNi6l1YXL9+HfXr1y+0X6PRaJMiIiKyNNIjLQ7GxLAkVapUwcqVK7Fo0SJcvnwZsiyjfv36cHJyMjim3oVF06ZNcfTo0ULzZ3fs2IFWrVoZnAgRERGZhpOTE1q0aCEklt6FxYwZMzBixAhcv34dGo0Gu3btwvnz57FlyxZ88803QpIqDyKmEeGxFUCNoi7+viv6kGzEjTWR89WlH1QGUlU3IXEAQM7+R0wgSdwkMMnB8EpeN5DAiWlKR3GxRBH1/grui4kDQLIXdJ1ExQEgC3p/kpO47zvJXszPOsnRWUyc+xXTwSBiVoeltViUB72/80NCQrB9+3Z89913kCQJH374IZKSkvD111+jW7du5ZEjERFRuRM5eNOaGbRAVo8ePdCjRw/RuRAREZGF07vFIi4uDidOnCi0/8SJE4iPjxeSFBERUUWTJDGbuWvdujVu374NAJg9ezZyc8V0zT+kd2ERFhaGlJSUQvuvX79u9vN1iYiIimMtK28mJSUhJycHADBr1ixkZ2cLja93V8i5c+fQunXrQvtbtWqFc+fOCUmKiIiIykfLli0xevRodOrUCbIs4+OPP0bVqlWLPPbDDz/UO77eLRZKpbLI5T9TU1Nha6tfnXLkyBGEhITAy8sLkiQhOjpa53lZljFz5kx4eXnB0dERQUFB+O233/RNmYiIqFTWMnhz06ZNqFGjBr755htIkoTvv/8eUVFRhbbHfyeXld4tFt26dUN4eDh2794NV1dXAMCdO3fw3nvv6T0rJCcnB/7+/hg9ejQGDBhQ6PmFCxdiyZIl2LRpExo2bIg5c+agW7duOH/+PJydxUxjIiIiAsSMkXh4fmBgIGxsbBAWFmZ2wwQaNWqEbdu2AQAUCgUOHjwId3d3YfH1LiwWL16MZ599Fr6+vtoFsRITE1G7dm189tlnesVSqVRQqVRFPifLMpYtW4b3339fu1755s2bUbt2bXzxxRd4/fXXizxPrVZDrf5vPYbMzEy9ciIiIjJWXFwcXFxcTJ1GqTQajfCYeneFPPHEEzh9+jQWLlwIPz8/tGnTBp988gnOnDkDb29vYYklJycjLS0N3bt31+5TKpXo3Lkzfvrpp2LPi4iIgKurq3YTmRMREVVe1jJ483GXL1/Gm2++ia5du6Jbt26YMGECLl++bHA8g9axcHJywmuvvWbwi5ZFWloaAKB27do6+2vXro0//vij2PPCw8MxZcoU7ePMzEwWF0REVCoRYyQsYYzFo/bt24fevXujZcuW6NixI2RZxk8//YSmTZsavPClQYXFhQsXcPjwYaSnpxdqRjFkBGlJpMc6vGRZLrTvUUqlEkqlUmgORERU+UkKGZLCyCW9YVmFxbvvvovJkydj/vz5hfZPmzatYgqLdevW4Y033kDNmjXh4eGh80v+4RLfInh4eAB40HLh6emp3Z+enl6oFYOIiIj0l5SUhP/7v/8rtH/MmDFYtmyZQTH1LizmzJmDuXPnYtq0aQa9YFnVq1cPHh4eiImJ0Q4SzcvLQ2xsLBYsWFCur01ERNZHgoBZIUIyqTi1atVCYmIiGjRooLM/MTHR4JkiehcWt2/fxsCBAw16scdlZ2fj0qVL2sfJyclITEyEm5sbfHx8MGnSJMybNw8NGjRAgwYNMG/ePFSpUgXDhg0T8vpEREQPSQoY3xViWT0hePXVV/Haa6/hypUr6NChAyRJwrFjx7BgwQK89dZbBsXUu7AYOHAg9u/fj7Fjxxr0go+Kj49HcHCw9vHDQZehoaHYtGkT3nnnHdy9exfjxo3D7du30bZtW+zfv59rWBAREQkwffp0ODs7Y/HixQgPDwcAeHl5YebMmZgwYYJBMfUuLOrXr4/p06fj+PHjaN68Oezs7HSe1yeRoKAgyHLx5Z0kSZg5cyZmzpypb5pERER6ETFd1NKmm0qShMmTJ2Py5MnIysoCAKP/eNe7sFi7di2qVq2K2NhYxMbGFkrQ0AqHiIjIlCQB000trbB4lKjeAL0Li+TkZCEvXNE0/25Geax1xhiSm5egQHqvcVY8WdAKbPfVpR9TRlJVNzGB8u6KiQMIu+aSnb2QOACAezli4ohchU8h6DopqwiJAwCyWsztoeXsf4TEAQCFqJ8FeQatHlAkyVFQd3NBvnnFoQoh7pNIRERkwR4M3jQyhuU2WAhjUGHx559/Ys+ePbh27Rry8vJ0nluyZImQxIiIiCqSyDEW5nwTsvKmd2Fx8OBB9O7dG/Xq1cP58+fRrFkzXL16FbIso3Xr1uWRIxERkUWxhJuQ5efno3v37lizZg0aNmwoLK7ejT7h4eF46623cPbsWTg4OGDnzp1ISUlB586dha1vQUREVNEeLult7GYp7OzscPbs2RJvk2EIvQuLpKQkhIaGAgBsbW1x9+5dVK1aFbNnz+aKmEREZLEkScxmSUaOHIn169cLjal3V4iTkxPU6gej/r28vHD58mU0bdoUAHDz5k29Yh05cgSLFi1CQkICUlNTERUVhb59+2qf37VrF9asWYOEhATcunULp06dQsuWLfVNmYiIqFRCbkJWwtpM5igvLw//+9//EBMTg4CAADg5Oek8b8i4Sb0Li3bt2uHHH3+En58fevXqhbfeegtnzpzBrl270K5dO71i5eTkwN/fH6NHj8aAAQOKfL5jx44YOHAgXn31VX1TJSIiohKcPXtWOz7ywoULOs8Z2kWid2GxZMkSZGdnAwBmzpyJ7OxsbN++HfXr18fSpUv1iqVSqaBSqYp9fsSIEQCAq1ev6psmERGRXqyxxeLQoUPCY+pdWDz55JPa/1epUgUrV64UmpCx1Gq1tqsGADIzM02YDRERWQoRYyQsbYzFQ5cuXcLly5fx7LPPwtHREbIsG9xioffgzSeffBK3bt0qtP/OnTs6RYepREREwNXVVbt5e3ubOiUiIiKzdOvWLTz33HNo2LAhnn/+eaSmpgIAXnnlFYPvbqp3YXH16lUUFBQU2q9Wq3H9+nWDkhApPDwcGRkZ2i0lJcXUKRERkQWwtummADB58mTY2dnh2rVrqFLlv+XzBw8ejL179xoUs8xdIXv27NH+f9++fXB1ddU+LigowMGDB1G3bl2DkhBJqVRCqVSaOg0iIrIwkiRgSW+Bt9upCPv378e+fftQp04dnf0NGjTAH3/8YVDMMhcWD6eBSpKkXcfiITs7O9StWxeLFy82KAkiIiKqeDk5OTotFQ/dvHnT4D/Sy1xYaP6962G9evUQFxeHmjVrGvSCj8rOzsalS5e0j5OTk5GYmAg3Nzf4+Pjgn3/+wbVr13Djxg0AwPnz5wEAHh4e8PDwMPr1iYiIHhJ5rxBL8eyzz2LLli346KOPADxoPNBoNFi0aBGCg4MNiinktul37txBtWrV9H7x+Ph4ncSnTJkCAAgNDcWmTZuwZ88ejB49Wvv8kCFDAAAzZszAzJkz9X49IiKi4gi5u6mR51e0RYsWISgoCPHx8cjLy8M777yD3377Df/88w9+/PFHg2LqfQkWLFiA7du3ax8PHDgQbm5ueOKJJ/Drr7/qFSsoKAiyLBfaNm3aBAAYNWpUkc+zqCAiIjKen58fTp8+jaeffhrdunVDTk4O+vfvj1OnTuGpp54yKKbeLRZr1qzB1q1bAQAxMTE4cOAA9u7di//7v//D1KlTsX//foMSISIiMiUhC2RZ2KwQ4MHwglmzZgmLp3dhkZqaql0b4ptvvsGgQYPQvXt31K1bF23bthWWGBERUUUS2RUSGBgIGxsbhIWFISwszPjkytHt27exfv16JCUlQZIkNGnSBKNHj4abm5tB8fQuLKpXr46UlBR4e3tj7969mDNnDgBAluUi17cwF7Yw4M0+TiOwElU6lX5MGcj31aUfVEaKaoIGxNoYfaW1ZHWukDhS1epC4gAAFDZCwsh3s4TEAQS+P4XADmJBnc2SncDp47KguYBVXEs/pqxs7MTFEkTOzRASR6pq2C+mQirqGknyg83YGADi4uLg4uIiIKnyFRsbiz59+sDFxQUBAQEAgOXLl2P27NnYs2cPOnfurHdMvX8D9O/fH8OGDUODBg1w69Yt7b0+EhMTUb9+fb0TICIiItMICwvDoEGDsGrVKtjYPPijqaCgAOPGjUNYWBjOnj2rd0y9C4ulS5eibt26SElJwcKFC1G1alUAD7pIxo0bp3cCRERE5sAaZ4VcvnwZO3fu1BYVAGBjY4MpU6Zgy5YtBsXUu7Cws7PD22+/XWj/pEmTDEqAiIjIHFhjYdG6dWskJSWhUaNGOvuTkpLQsmVLg2KWqbDYs2cPVCoV7OzsdJb2Lkrv3r0NSoSIiIjK3+nTp7X/nzBhAiZOnIhLly6hXbt2AIDjx49jxYoVmD9/vkHxy1RY9O3bF2lpaXB3d9cu7V0USZL0GsB55MgRLFq0CAkJCUhNTUVUVJQ2fn5+Pj744AN89913uHLlClxdXdG1a1fMnz8fXl5eZX4NIiKisrCWFouWLVtCkiTI8n8DVd95551Cxw0bNgyDBw/WO36ZCouHy3k//n9j5eTkwN/fH6NHj8aAAQN0nsvNzcXJkycxffp0+Pv74/bt25g0aRJ69+6N+Ph4YTkQEREBeLBkpLGFgQUUFkWtoC2SuHmBBlCpVNpZJY9zdXVFTEyMzr5PP/0UTz/9NK5duwYfH5+KSJGIiKhS8fX1Ldf4ehUWGo0GmzZtwq5du3D16lVIkoR69erhxRdfxIgRIyBJUnnlCQDIyMiAJEkl3pdErVZDrf5vbYfMzMxyzYmIiCoHIbdNL99fg+Xi+vXr+PHHH5Genl6oV2LChAl6xytzYSHLMnr37o3vvvsO/v7+aN68OWRZRlJSEkaNGoVdu3YhOjpa7wTK6t69e3j33XcxbNiwEhcdiYiIELo0KRERWQkr6Qp51MaNGzF27FjY29ujRo0aOg0EkiSVb2GxadMmHDlyBAcPHix0K9UffvgBffv2xZYtWzBy5Ei9kyhNfn4+hgwZAo1Gg5UrV5Z4bHh4uPYuqcCDFouHS5ATERHRfz788EN8+OGHCA8Ph0LQyrtljvLll1/ivffeK/L+7F26dMG7776Lzz//XEhSj8rPz8egQYOQnJyMmJiYUpdIVSqVcHFx0dmIiIhKpfhvZoihm6W1WOTm5mLIkCHCigpAj0tw+vRp9OzZs9jnVSqV3rdNL83DouLixYs4cOAAatSoITQ+ERGRlkLQZkFefvll7NixQ2jMMneF/PPPP6hdu3axz9euXRu3b9/W68Wzs7Nx6dIl7ePk5GQkJibCzc0NXl5eePHFF3Hy5El88803KCgoQFpaGgDAzc0N9vb2er0WERFRSSSFBElh3OhLY8+vaBEREXjhhRewd+9eNG/eHHZ2ujd8W7Jkid4xy1xYFBQUwNa2+MNtbGxw//59vV48Pj5ep2vl4diI0NBQzJw5U7vK5+PLih46dAhBQUF6vRYRERHpmjdvHvbt26dd0vvxwZuG0GtWyKhRo6BUFn0L40eneJZVUFCQzspfRb0mERFRhbDCWSFLlizBhg0bMGrUKGExy1xYhIaGlnpMecwIISIiqgjW2BWiVCrRsWNHoTHLXFhs3LhR6AsTERFVVoGBgbCxsUFYWBjCwsJMnU6xJk6ciE8//RTLly8XFtOkS3pXpPv/bkbJ07+7p/hYd4WEkRychMQBAE22foNviyMJnLYki7o3jabsN8cr1f08MXGU4r528t0sMXEKjP4u+Y+g6yTfyxESBwBkUV87UXEAIF/MzxVZ0M8UAJAcncUEEvV9J/L7tyQCu0Li4uIsYrmDX375BT/88AO++eYbNG3atNDgzV27dukd02oKCyIiohIppAebsTEsSLVq1dC/f3+hMVlYEBERWanyGObAwoKIiAgPplcaPXjTEu9CJhgLCyIiIsAqp5vWq1evxGLoypUresdkYUFERGSlJk2apPM4Pz8fp06dwt69ezF16lSDYpq0sDhy5AgWLVqEhIQEpKamIioqCn379tU+P3PmTGzbtg0pKSmwt7dHmzZtMHfuXLRt29Z0SRMRUeVkhYM3J06cWOT+FStWID4+3qCYJm20ycnJgb+/PyIjI4t8vmHDhoiMjMSZM2dw7Ngx1K1bF927d8fff/9dwZkSEVFl93CBLGO3ykClUmHnzp0GnWvSFguVSgWVSlXs88OGDdN5vGTJEqxfvx6nT5/Gc889V97pERGRNbHCFovifPXVV3BzczPoXIsZY5GXl4e1a9fC1dUV/v7+xR6nVqt17luSmZlZEekRERFZnFatWukM3pRlGWlpafj777+xcuVKg2KafWHxzTffYMiQIcjNzYWnpydiYmJQs2bNYo+PiIjArFmzKjBDIiKqFKywxeLRcY0AoFAoUKtWLQQFBaFx48YGxTT7wiI4OBiJiYm4efMm1q1bh0GDBuHEiRNwd3cv8vjw8HDt7deBBy0W3t7eFZUuERFZKEmSjF6HwtLWsZgxY4bwmGY/49bJyQn169dHu3btsH79etja2mL9+vXFHq9UKuHi4qKzERERUcUw+xaLx8myrDOGgoiISAgr6gpRKBSltq5IkoT79/W/MaFJC4vs7GxcunRJ+zg5ORmJiYlwc3NDjRo1MHfuXPTu3Ruenp64desWVq5ciT///BMDBw40YdZERFQpKSCgsBCSSbmLiooq9rmffvoJn376KWRZNii2SQuL+Ph4BAcHax8/HBsRGhqK1atX4/fff8fmzZtx8+ZN1KhRA4GBgTh69CiaNm1qqpSJiIgsXp8+fQrt+/333xEeHo6vv/4aL730Ej766CODYpu0sAgKCiqxIjLkPvBEREQGUSgebMbGsDA3btzAjBkzsHnzZvTo0QOJiYlo1qyZwfEs7woQERGVB0n6b5yFoZsFzQrJyMjAtGnTUL9+ffz22284ePAgvv76a6OKCsACB28SERGRcRYuXIgFCxbAw8MDX375ZZFdI4aymsJC/nczF3LuHTGB7B3FxAGA+2Jm28i2SiFxAAB5d8XEsXcQEwcAbO3FxFHniIkDAAX6j9wukkYjJg4A+W6WmECSuIZVydFZSBzNPYFfO1HXSWQTvCzoc6CwMa84pRBxrw9LuVfIu+++C0dHR9SvXx+bN2/G5s2bizzOkCEJVlNYEBERlciKppuOHDmy3BbzYmFBREQEPGgdM7aFTGALW3natGlTucW2jCtARERkQQIDA+Hn54cVK1aYOpUKxxYLIiIiQGhXSFxcnNXeUsKkLRZHjhxBSEgIvLy8IEkSoqOjiz329ddfhyRJWLZsWYXlR0REVsTYqaYiCpNKwKSFRU5ODvz9/REZGVnicdHR0Thx4gS8vLwqKDMiIiIyhEm7QlQqFVQqVYnHXL9+HePHj8e+ffvQq1evCsqMiIisjaRQQDJy2q6x51cGZj3GQqPRYMSIEZg6dWqZ7w+iVqt17n6amZlZXukREVFlYkXTTcuTWZdWCxYsgK2tLSZMmFDmcyIiIuDq6qrdvL29yzFDIiIiepTZFhYJCQn45JNPsGnTJr0W8QgPD0dGRoZ2S0lJKccsiYio0ni4joWxm5Uz2ytw9OhRpKenw8fHB7a2trC1tcUff/yBt956C3Xr1i32PKVSCRcXF52NiIioVJwVIoTZjrEYMWIEunbtqrOvR48eGDFiBEaPHm2irIiIiKgkJi0ssrOzcenSJe3j5ORkJCYmws3NDT4+PqhRo4bO8XZ2dvDw8ECjRo0qOlUiIqrsJIXxN3NjV4hpC4v4+HgEBwdrH0+ZMgUAEBoaWq7rmBMRERXCWSFCmLSwCAoKgiyX/WbmV69eLb9kiIjIukmSgJuQsbBgmw0REREJY7aDN4mIiCoUu0KEsJrCQvp3MxsajZAwIpePle+rSz+oLGyVYuKIdD9PXCxbezFxRA7yyrsnJk5Bvpg4IslivlcAQFbnCIkjdNlmUe+v4L6YOICw72H5bpagONlC4pSGS3qLwStAREREwlhNiwUREVGJ2BUiBAsLIiIiQMyS3FzHgl0hREREJA5bLIiIiAB2hQhi0haLI0eOICQkBF5eXpAkCdHR0TrPjxo1CpIk6Wzt2rUzTbJERFS5KRRiNitn0iuQk5MDf39/REZGFntMz549kZqaqt2+++67CsyQiIiI9GHSrhCVSgWVSlXiMUqlEh4eHhWUERERWS1JMn5Jbi7pbf6DNw8fPgx3d3c0bNgQr776KtLT00s8Xq1WIzMzU2cjIiIqlSSgG4SzQsy7sFCpVPj888/xww8/YPHixYiLi0OXLl2gVhe/QmRERARcXV21m7e3dwVmTEREFotjLIQw61khgwcP1v6/WbNmCAgIgK+vL7799lv079+/yHPCw8O1t18HgMzMTBYXREREFcSsC4vHeXp6wtfXFxcvXiz2GKVSCaXSDO9VQURE5o3TTYWwqMLi1q1bSElJgaenp6lTISKiykaSBKy8ycLCpJ1B2dnZSExMRGJiIgAgOTkZiYmJuHbtGrKzs/H222/j559/xtWrV3H48GGEhISgZs2a6NevnynTJiIiKlFgYCD8/PywYsUKU6dS4UzaYhEfH4/g4GDt44djI0JDQ7Fq1SqcOXMGW7ZswZ07d+Dp6Yng4GBs374dzs7OpkqZiIgqKxGDL/89Py4uDi4uLgKSsjwmLSyCgoIgy3Kxz+/bt68CsyEiImsmKSRIRo6RMPb8yoDzYoiIiEgYixq8SUREVG5423QhrKawUMoylCV0u5SJwNG+UlU3MYHsHcXEASDZ2guJI+fdExIHgLjFZgReJ7P8wVG9tpAwksjr5ChmLJRUxVVIHADQZN0UEkfh9oSQOAAg590VE+hejpg4ACBrhIQR9bWTCmyExCmVwDEW1oxXgIiIiISxmhYLIiKiErHFQggWFkRERADvbioICwsiIiKALRaCmPQKHDlyBCEhIfDy8oIkSYiOji50TFJSEnr37g1XV1c4OzujXbt2uHbtWsUnS0RERKUyaWGRk5MDf39/REZGFvn85cuX0alTJzRu3BiHDx/Gr7/+iunTp8PBwaGCMyUiospP8d+UU0M3zokwbVeISqWCSqUq9vn3338fzz//PBYuXKjd9+STT1ZEakREZG3YFSKE2V4BjUaDb7/9Fg0bNkSPHj3g7u6Otm3bFtld8ii1Wo3MzEydjYiIiCqG2RYW6enpyM7Oxvz589GzZ0/s378f/fr1Q//+/REbG1vseREREXB1ddVu3t7eFZg1ERFZLIX0X6uFwRtnhZjtrBCN5sHKb3369MHkyZMBAC1btsRPP/2E1atXo3PnzkWeFx4err1LKgBkZmayuCAiotJxuqkQZltY1KxZE7a2tvDz89PZ36RJExw7dqzY85RKJZRKZXmnR0REREUw28LC3t4egYGBOH/+vM7+CxcuwNfX10RZERFRpcXBm0KYtLDIzs7GpUuXtI+Tk5ORmJgINzc3+Pj4YOrUqRg8eDCeffZZBAcHY+/evfj6669x+PBh0yVNRESVEwsLIUxaWMTHxyM4OFj7+OHYiNDQUGzatAn9+vXD6tWrERERgQkTJqBRo0bYuXMnOnXqZKqUiYiIqAQmLSyCgoIgl3Ir8zFjxmDMmDEVlBEREVkt7SJXRsawcmY7xoKIiKhCsStECBYWREREAFssBLGawiLDRkKesQuXCKxE5fSrwmIJYyPo4yCyYi+4LySMnP2PkDgAIFV1ExJHzkwXEgcAkJMhJIyszhESBwDku1li4vy7po0Qko2QMJrUC0LiAIBUQ9A6O5p8MXEAyPcEfQ4KxOQkZ4v7XFL5s5rCgoiIqETsChGChQURERHArhBBeAWIiIhIGLZYEBERAewKEYSFBREREfDgBmLGFga8CZlpu0KOHDmCkJAQeHl5QZIkREdH6zwvSVKR26JFi0yTMBEREZXIpIVFTk4O/P39ERkZWeTzqampOtuGDRsgSRIGDBhQwZkSEVGl93DwprGblTNpV4hKpYJKpSr2eQ8PD53Hu3fvRnBwMJ588snyTo2IiKwNx1gIYTFjLP766y98++232Lx5c4nHqdVqqNVq7ePMzMzyTo2IiIj+ZTGl1ebNm+Hs7Iz+/fuXeFxERARcXV21m7e3oFXtiIiocmNXiBAWcwU2bNiAl156CQ4ODiUeFx4ejoyMDO2WkpJSQRkSEZFFe9gVYuxm5SyiK+To0aM4f/48tm/fXuqxSqUSSqWyArIiIqJKhStvCmERV2D9+vVo06YN/P39TZ0KERERlcCkLRbZ2dm4dOmS9nFycjISExPh5uYGHx8fAA8GX+7YsQOLFy82VZpERGQNOCtECJMWFvHx8QgODtY+njJlCgAgNDQUmzZtAgBs27YNsixj6NChpkiRiIishCTZQJJsjI5h7UxaWAQFBUGW5RKPee211/Daa69VUEZERERkDIsYvElERFTuFALuFaLgvULYGURERAQInW4aGBgIPz8/rFixwsRvquJZTYuFUgMYPQn1kRU9jeZSQ0yc+wJzEkSycxIWSy7IEhOoIF9MHADyXTGrucoF94XEAQDk5wkJI2ffFhJHJEngYDhZoxETSCnuM458Qd/DDi5i4gCQbKzmV0O5iYuLg4uLuK+JJeGnh4iICOA6FoKwsCAiIgIeFAXGtpCxsOAYCyIiIhKHLRZEREQAu0IEMekVOHLkCEJCQuDl5QVJkhAdHa3zfHZ2NsaPH486derA0dERTZo0wapVq0yTLBERVW4KGzGblTNpYZGTkwN/f39ERkYW+fzkyZOxd+9ebN26FUlJSZg8eTLefPNN7N69u4IzJSKiSo+3TRfCpF0hKpUKKpWq2Od//vlnhIaGIigoCMCDVTjXrFmD+Ph49OnTp4KyJCIiorIy69KqU6dO2LNnD65fvw5ZlnHo0CFcuHABPXr0KPYctVqNzMxMnY2IiKhUAhfIsmZmfQWWL18OPz8/1KlTB/b29ujZsydWrlyJTp06FXtOREQEXF1dtZu3t3cFZkxERBaLXSFCmPUVWL58OY4fP449e/YgISEBixcvxrhx43DgwIFizwkPD0dGRoZ2S0lJqcCMiYiIrJvZTje9e/cu3nvvPURFRaFXr14AgBYtWiAxMREff/wxunbtWuR5SqUSSqXRi3cTEZGVkSSFgNumm/Xf6xXCbAuL/Px85OfnQ/FYf5WNjQ00otb7JyIiekjEGAmOsTBtYZGdnY1Lly5pHycnJyMxMRFubm7w8fFB586dMXXqVDg6OsLX1xexsbHYsmULlixZYsKsiYiIqDgmLSzi4+MRHBysfTxlyhQAQGhoKDZt2oRt27YhPDwcL730Ev755x/4+vpi7ty5GDt2rKlSJiKiyoorbwph0sIiKCgIsiwX+7yHhwc2btxYgRkREZHVYleIELwCREREJIzZDt4kIiKqUOwKEYKFhYlItvZiAimdxMQBgIL7QsLIBflC4gAQ9v4kO/Obgiw51xQWS5ObJSSOVLW6kDgAIGffFhZLFElQM7UscmKaoGDynVQhcQAAru5Cwkj2jkLiVBgRNxHjTchYWBAREQFgi4UgvAJEREQkDFssiIiIgAetDcZ2l7HFgoUFERERAEiSZPSS3JIkCcrGcrG0IiIiImFMWlgcOXIEISEh8PLygiRJiI6O1nn+r7/+wqhRo+Dl5YUqVaqgZ8+euHjxommSJSKiyu3hAlnGblbOpFcgJycH/v7+iIyMLPScLMvo27cvrly5gt27d+PUqVPw9fVF165dkZOTY4JsiYioUns4K8TYzcqZdIyFSqWCSqUq8rmLFy/i+PHjOHv2LJo2bQoAWLlyJdzd3fHll1/ilVdeKfI8tVoNtVqtfZyZmSk+cSIiIiqS2ZZWD4sDBwcH7T4bGxvY29vj2LFjxZ4XEREBV1dX7ebt7V3uuRIRUSXwcIEsYzcrZ7aFRePGjeHr64vw8HDcvn0beXl5mD9/PtLS0pCaWvwKc+Hh4cjIyNBuKSkpFZg1ERFZLHaFCGG2V8DOzg47d+7EhQsX4ObmhipVquDw4cNQqVSwsSm+IlQqlXBxcdHZiIiIqGKY9ToWbdq0QWJiIjIyMpCXl4datWqhbdu2CAgIMHVqRERU2fC26UJYxBVwdXVFrVq1cPHiRcTHx6NPnz6mTomIiCoZSVII2aydSVsssrOzcenSJe3j5ORkJCYmws3NDT4+PtixYwdq1aoFHx8fnDlzBhMnTkTfvn3RvXt3E2ZNRESVElsshDBpYREfH4/g4GDt4ylTpgAAQkNDsWnTJqSmpmLKlCn466+/4OnpiZEjR2L69OmmSpeIiIhKYdLCIigoCLIsF/v8hAkTMGHChArMiIiIrBZvmy6EWQ/eJCIiqjAKhfHrULArpPIXFg9bRO5p8o2OlXlXXfpBZaTIzhUTyPi39Z+CAjFx7AQmpdEICSPZ3RcSx1xpcu4KiaPIFrdcvizoMy4VmN8PalnQ5xIAJEHfL5ocQT9TAEg2Yj4Hkr2Y65T17+eypBZuETKzss0ihqWT5PL+SpnYn3/+ydU3iYgqgZSUFNSpU0d43Hv37qFevXpIS0sTEs/DwwPJyck6K0dbk0pfWGg0Gty4cQPOzs6QJKnIYzIzM+Ht7Y2UlBSjF9QSFYs5MSfmZLk5Veb3ZoqcZFlGVlYWvLy8oCinroZ79+4hLy9PSCx7e3urLSoAK+gKUSgUZa5wRa7UKSoWc6rYOCJjMaeKjSMylrnFERnLUnNydXU1+nVK4uDgYNXFgEjm13lJREREFouFBREREQnDwgIPblw2Y8YMKJVKs4nFnJgTc7LcnCrzezPXnMh8VPrBm0RERFRx2GJBREREwrCwICIiImFYWBAREZEwLCyIiIhIGBYWAFauXIl69erBwcEBbdq0wdGjR/WOceTIEYSEhMDLywuSJCE6OtqgXCIiIhAYGAhnZ2e4u7ujb9++OH/+vN5xVq1ahRYtWmgXnmnfvj2+//57g3J6PD9JkjBp0iS9z505cyYkSdLZPDw8DM7l+vXrGD58OGrUqIEqVaqgZcuWSEhI0CtG3bp1C+UkSRLCwsL0zuf+/fv44IMPUK9ePTg6OuLJJ5/E7NmzoTHgvhJZWVmYNGkSfH194ejoiA4dOiAuLq7U80r7HMqyjJkzZ8LLywuOjo4ICgrCb7/9pnecXbt2oUePHqhZsyYkSUJiYqJBOeXn52PatGlo3rw5nJyc4OXlhZEjR+LGjRt65zRz5kw0btwYTk5OqF69Orp27YoTJ04YdJ0e9frrr0OSJCxbtkzvOKNGjSr02WrXrp3BOSUlJaF3795wdXWFs7Mz2rVrh2vXrukVp6jPuyRJWLRokd45ZWdnY/z48ahTpw4cHR3RpEkTrFq1Su84f/31F0aNGgUvLy9UqVIFPXv2xMWLF4u8TmT+rL6w2L59OyZNmoT3338fp06dwjPPPAOVSlXom7U0OTk58Pf3R2RkpFH5xMbGIiwsDMePH0dMTAzu37+P7t27IydHv5sC1alTB/Pnz0d8fDzi4+PRpUsX9OnTp8hfImUVFxeHtWvXokWLFgbHaNq0KVJTU7XbmTNnDIpz+/ZtdOzYEXZ2dvj+++9x7tw5LF68GNWqVdMrTlxcnE4+MTExAICBAwfqndOCBQuwevVqREZGIikpCQsXLsSiRYvw6aef6h3rlVdeQUxMDD777DOcOXMG3bt3R9euXXH9+vUSzyvtc7hw4UIsWbIEkZGRiIuLg4eHB7p164asrCy94uTk5KBjx46YP39+qe+lpFi5ubk4efIkpk+fjpMnT2LXrl24cOECevfurfd7a9iwISIjI3HmzBkcO3YMdevWRffu3fH333/rHeuh6OhonDhxAl5eXnq/t4d69uyp8xn77rvvDIp1+fJldOrUCY0bN8bhw4fx66+/Yvr06YVWiywtzqO5pKamYsOGDZAkCQMGDNA7p8mTJ2Pv3r3YunUrkpKSMHnyZLz55pvYvXt3mePIsoy+ffviypUr2L17N06dOgVfX1907dpV7597ZCZkK/f000/LY8eO1dnXuHFj+d133zU4JgA5KirKyMweSE9PlwHIsbGxRseqXr26/L///c+gc7OysuQGDRrIMTExcufOneWJEyfqHWPGjBmyv7+/Qa//uGnTpsmdOnUSEutREydOlJ966ilZo9HofW6vXr3kMWPG6Ozr37+/PHz4cL3i5ObmyjY2NvI333yjs9/f319+//33yxzn8c+hRqORPTw85Pnz52v33bt3T3Z1dZVXr15d5jiPSk5OlgHIp06dMiinovzyyy8yAPmPP/4wKk5GRoYMQD5w4IBBOf3555/yE088IZ89e1b29fWVly5dqnec0NBQuU+fPiWeV9ZYgwcP1vuzVJbr1KdPH7lLly4GxWratKk8e/ZsnX2tW7eWP/jggzLHOX/+vAxAPnv2rHbf/fv3ZTc3N3ndunWl5kXmx6pbLPLy8pCQkIDu3bvr7O/evTt++uknE2WlKyMjAwDg5uZmcIyCggJs27YNOTk5aN++vUExwsLC0KtXL3Tt2tXgPADg4sWL8PLyQr169TBkyBBcuXLFoDh79uxBQEAABg4cCHd3d7Rq1Qrr1q0zKre8vDxs3boVY8aMKfaGdSXp1KkTDh48iAsXLgAAfv31Vxw7dgzPP/+8XnHu37+PgoKCQn+JOjo64tixY3rn9VBycjLS0tJ0Pu9KpRKdO3c2m8878OAzL0mS3q1Pj8rLy8PatWvh6uoKf39/vc/XaDQYMWIEpk6diqZNmxqcBwAcPnwY7u7uaNiwIV599VWkp6cblM+3336Lhg0bokePHnB3d0fbtm0N7nJ96K+//sK3336Ll19+2aDzO3XqhD179uD69euQZRmHDh3ChQsX0KNHjzLHUKvVAKDzebexsYG9vb1Rn3cyHasuLG7evImCggLUrl1bZ3/t2rWF3T7XGLIsY8qUKejUqROaNWum9/lnzpxB1apVoVQqMXbsWERFRcHPz0/vONu2bcPJkycRERGh97mPatu2LbZs2YJ9+/Zh3bp1SEtLQ4cOHXDr1i29Y125cgWrVq1CgwYNsG/fPowdOxYTJkzAli1bDM4vOjoad+7cwahRoww6f9q0aRg6dCgaN24MOzs7tGrVCpMmTcLQoUP1iuPs7Iz27dvjo48+wo0bN1BQUICtW7fixIkTSE1NNSg3ANrPtLl+3oEHd5h89913MWzYMINubvXNN9+gatWqcHBwwNKlSxETE4OaNWvqHWfBggWwtbXFhAkT9D73USqVCp9//jl++OEHLF68GHFxcejSpYv2l2lZpaenIzs7G/Pnz0fPnj2xf/9+9OvXD/3790dsbKzB+W3evBnOzs7o37+/QecvX74cfn5+qFOnDuzt7dGzZ0+sXLkSnTp1KnOMxo0bw9fXF+Hh4bh9+zby8vIwf/58pKWlGfV5J9Op9Hc3LYvH/zqVZdmgv1hFGz9+PE6fPm1w1d6oUSMkJibizp072LlzJ0JDQxEbG6tXcZGSkoKJEydi//79Rt/5T6VSaf/fvHlztG/fHk899RQ2b96MKVOm6BVLo9EgICAA8+bNAwC0atUKv/32G1atWoWRI0calN/69euhUqmK7U8vzfbt27F161Z88cUXaNq0KRITEzFp0iR4eXkhNDRUr1ifffYZxowZgyeeeAI2NjZo3bo1hg0bhpMnTxqU26PM9fOen5+PIUOGQKPRYOXKlQbFCA4ORmJiIm7evIl169Zh0KBBOHHiBNzd3cscIyEhAZ988glOnjxp9HUZPHiw9v/NmjVDQEAAfH198e233+r1y/zhAOA+ffpg8uTJAICWLVvip59+wurVq9G5c2eD8tuwYQNeeuklg7+3ly9fjuPHj2PPnj3w9fXFkSNHMG7cOHh6epa5ddPOzg47d+7Eyy+/DDc3N9jY2KBr1646Py/Islh1i0XNmjVhY2NT6K+19PT0Qn/VVbQ333wTe/bswaFDh8p82/fH2dvbo379+ggICEBERAT8/f3xySef6BUjISEB6enpaNOmDWxtbWFra4vY2FgsX74ctra2KCgoMCg3AHByckLz5s0NGv3t6elZqEBq0qSJ3oNuH/rjjz9w4MABvPLKKwadDwBTp07Fu+++iyFDhqB58+YYMWIEJk+ebFBLz1NPPYXY2FhkZ2cjJSUFv/zyC/Lz81GvXj2D83s4A8ccP+/5+fkYNGgQkpOTERMTY/CtuJ2cnFC/fn20a9cO69evh62tLdavX69XjKNHjyI9PR0+Pj7az/wff/yBt956C3Xr1jUor4c8PT3h6+ur92e+Zs2asLW1FfqZP3r0KM6fP2/wZ/7u3bt47733sGTJEoSEhKBFixYYP348Bg8ejI8//livWG3atNH+EZSamoq9e/fi1q1bRn3eyXSsurCwt7dHmzZttDMBHoqJiUGHDh1MkpMsyxg/fjx27dqFH374Qeg3lizLejfBPvfcczhz5gwSExO1W0BAAF566SUkJibCxsbG4HzUajWSkpLg6emp97kdO3YsNA33woUL8PX1NSiXjRs3wt3dHb169TLofODBDAeFQvdbysbGxqDppg85OTnB09MTt2/fxr59+9CnTx+DY9WrVw8eHh46n/e8vDzExsaa7PMO/FdUXLx4EQcOHECNGjWExTbkMz9ixAicPn1a5zPv5eWFqVOnYt++fUblc+vWLaSkpOj9mbe3t0dgYKDQz/z69evRpk0bg8agAA++bvn5+UI/866urqhVqxYuXryI+Ph4oz7vZDpW3xUyZcoUjBgxAgEBAWjfvj3Wrl2La9euYezYsXrFyc7OxqVLl7SPk5OTkZiYCDc3N/j4+JQ5TlhYGL744gvs3r0bzs7O2r8uXV1d4ejoWOY47733HlQqFby9vZGVlYVt27bh8OHD2Lt3b9nfFB709z8+vsPJyQk1atTQe9zH22+/jZCQEPj4+CA9PR1z5sxBZmam3t0EwINpbh06dMC8efMwaNAg/PLLL1i7di3Wrl2rdyyNRoONGzciNDQUtraGf0uEhIRg7ty58PHxQdOmTXHq1CksWbIEY8aM0TvWvn37IMsyGjVqhEuXLmHq1Klo1KgRRo8eXeJ5pX0OJ02ahHnz5qFBgwZo0KAB5s2bhypVqmDYsGF6xfnnn39w7do17XoTD3/heXh4FFqbpKRYXl5eePHFF3Hy5El88803KCgo0H7m3dzcYG9vX6Y4NWrUwNy5c9G7d294enri1q1bWLlyJf78888ipw6X9v4eL27s7Ozg4eGBRo0alTmOm5sbZs6ciQEDBsDT0xNXr17Fe++9h5o1a6Jfv3565zR16lQMHjwYzz77LIKDg7F37158/fXXOHz4sF5xACAzMxM7duzA4sWLC+WhT6zOnTtj6tSpcHR0hK+vL2JjY7FlyxYsWbJErzg7duxArVq14OPjgzNnzmDixIno27dvoYH1ZCFMNyHFfKxYsUL29fWV7e3t5datWxs0tfPQoUMygEJbaGioXnGKigFA3rhxo15xxowZo31PtWrVkp977jl5//79esUojqHTTQcPHix7enrKdnZ2speXl9y/f3/5t99+MziPr7/+Wm7WrJmsVCrlxo0by2vXrjUozr59+2QA8vnz5w3ORZZlOTMzU544caLs4+MjOzg4yE8++aT8/vvvy2q1Wu9Y27dvl5988knZ3t5e9vDwkMPCwuQ7d+6Uel5pn0ONRiPPmDFD9vDwkJVKpfzss8/KZ86c0TvOxo0bi3x+xowZesV6OF21qO3QoUNljnP37l25X79+speXl2xvby97enrKvXv3ln/55ReDrtPjiptuWlKc3NxcuXv37nKtWrVkOzs72cfHRw4NDZWvXbtmcE7r16+X69evLzs4OMj+/v5ydHS0QXHWrFkjOzo6lvqZKi1WamqqPGrUKNnLy0t2cHCQGzVqJC9evLjQdO3S4nzyySdynTp1tNfpgw8+MOj7hswDb5tOREREwlj1GAsiIiISi4UFERERCcPCgoiIiIRhYUFERETCsLAgIiIiYVhYEBERkTAsLIiIiEgYFhZEREQkDAsLohJIkoTo6GhTp2FWRowYob2rLADUrVsXy5YtMypmeno6atWqhevXrxuZHRGZGgsLsjqjRo2CJEmQJAl2dnaoXbs2unXrhg0bNhS6eVJqamqZb99sSUXIunXr8Mwzz6B69eqoXr06unbtil9++aXU806fPo1vv/0Wb775ptB83N3dMWLECMyYMUNoXCKqeCwsyCr17NkTqampuHr1Kr7//nsEBwdj4sSJeOGFF3D//n3tcR4eHlAqlSbMtHwcPnwYQ4cOxaFDh/Dzzz/Dx8cH3bt3L7XFIDIyEgMHDoSzs7PwnEaPHo3PP/8ct2/fFh6biCoOCwuySkqlEh4eHnjiiSfQunVrvPfee9i9eze+//57bNq0SXvco60QeXl5GD9+PDw9PeHg4IC6desiIiICwIPuAADo168fJEnSPr58+TL69OmD2rVro2rVqggMDMSBAwd0cqlbty7mzZuHMWPGwNnZGT4+PoXu0vrnn39iyJAhcHNzg5OTEwICAnDixAnt819//TXatGkDBwcHPPnkk5g1a5ZOgfS4zz//HOPGjUPLli3RuHFjrFu3DhqNBgcPHiz2HI1Ggx07dqB3796FnsvKysKwYcNQtWpVeHl54dNPP9V5XpIkrFq1CiqVCo6OjqhXrx527Nihc0zz5s3h4eGBqKioYnMgIvPHwoLoX126dIG/vz927dpV5PPLly/Hnj178H//9384f/48tm7dqi0g4uLiAAAbN25Eamqq9nF2djaef/55HDhwAKdOnUKPHj0QEhKCa9eu6cRevHgxAgICcOrUKYwbNw5vvPEGfv/9d22Mzp0748aNG9izZw9+/fVXvPPOO9pum3379mH48OGYMGECzp07hzVr1mDTpk2YO3dumd97bm4u8vPz4ebmVuwxp0+fxp07dxAQEFDouUWLFqFFixY4efIkwsPDMXnyZMTExOgcM336dAwYMAC//vorhg8fjqFDhyIpKUnnmKeffhpHjx4tc95EZIZMfXtVoooWGhoq9+nTp8jnBg8eLDdp0kT7GIAcFRUly7Isv/nmm3KXLl0K3RK6qGNL4ufnJ3/66afax76+vvLw4cO1jzUajezu7i6vWrVKluUHt7h2dnaWb926VWS8Z555Rp43b57Ovs8++0z29PQsNZeHxo0bJz/11FPy3bt3iz0mKipKtrGxKfT+fX195Z49e+rsGzx4sKxSqbSPAchjx47VOaZt27byG2+8obNv8uTJclBQUJnzJiLzwxYLokfIsgxJkop8btSoUUhMTESjRo0wYcIE7N+/v9R4OTk5eOedd+Dn54dq1aqhatWq+P333wu1WLRo0UL7f0mS4OHhgfT0dABAYmIiWrVqVWxrQkJCAmbPno2qVatqt1dffRWpqanIzc0tNceFCxfiyy+/xK5du+Dg4FDscXfv3oVSqSzy+rRv377Q48dbI8pyjKOjY5lyJiLzZWvqBIjMSVJSEurVq1fkc61bt0ZycjK+//57HDhwAIMGDULXrl3x1VdfFRtv6tSp2LdvHz7++GPUr18fjo6OePHFF5GXl6dznJ2dnc5jSZK0XR2Ojo4l5qzRaDBr1iz079+/0HMlFQoA8PHHH2PevHk4cOCATnFTlJo1ayI3Nxd5eXmwt7cv8VgAxRZoJR3zzz//oFatWqWeR0Tmiy0WRP/64YcfcObMGQwYMKDYY1xcXDB48GCsW7cO27dvx86dO/HPP/8AeFAcFBQU6Bx/9OhRjBo1Cv369dMOTrx69apeebVo0QKJiYna13lc69atcf78edSvX7/QplAU/y2+aNEifPTRR9i7d2+R4yYe17JlSwDAuXPnCj13/PjxQo8bN26s9zFnz55Fq1atSs2FiMwXWyzIKqnVaqSlpaGgoAB//fUX9u7di4iICLzwwgsYOXJkkecsXboUnp6eaNmyJRQKBXbs2AEPDw9Uq1YNwIPZHQcPHkTHjh2hVCpRvXp11K9fH7t27UJISAgkScL06dMLrZVRmqFDh2LevHno27cvIiIi4OnpiVOnTsHLywvt27fHhx9+iBdeeAHe3t4YOHAgFAoFTp8+jTNnzmDOnDlFxly4cCGmT5+OL774AnXr1kVaWhoAaLtSilKrVi20bt0ax44d0xYZD/34449YuHAh+vbti5iYGOzYsQPffvutzjE7duxAQEAAOnXqhM8//xy//PIL1q9fr30+NzcXCQkJOotvEZEFMvUgD6KKFhoaKgOQAci2trZyrVq15K5du8obNmyQCwoKdI7FIwMy165dK7ds2VJ2cnKSXVxc5Oeee04+efKk9tg9e/bI9evXl21tbWVfX19ZlmU5OTlZDg4Olh0dHWVvb285MjJS7ty5szxx4kTteb6+vvLSpUt1Xtff31+eMWOG9vHVq1flAQMGyC4uLnKVKlXkgIAA+cSJE9rn9+7dK3fo0EF2dHSUXVxc5Kefflpeu3ZtsdfA19dXew0e3R59zaKsXr1abteuXaFYs2bNkgcNGiRXqVJFrl27trxs2bJC13HFihVyt27dZKVSKfv6+spffvmlzjFffPGF3KhRoxJfn4jMnyTLsmyyqoaILMq9e/fQqFEjbNu2rdBgzJJIkoSoqCj07du32GOefvppTJo0CcOGDROQKRGZCsdYEFGZOTg4YMuWLbh586bQuOnp6XjxxRcxdOhQoXGJqOKxxYKIyl1ZWiyIqHLg4E0iKnf8+4XIerArhIiIiIRhYUFERETCsLAgIiIiYVhYEBERkTAsLIiIiEgYFhZEREQkDAsLIiIiEoaFBREREQnz//bAfCMMTZFzAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -515,14 +552,9 @@
     "cb.set_label('Number of duplicates')"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -531,12 +563,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -558,12 +590,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -593,11 +625,23 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "test",
    "language": "python",
-   "name": "python3"
+   "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.10.6"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }
diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index c3a79622..99efccd5 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -106,7 +106,6 @@ class CommandFormatter():
         command (Optional[Union[List[str], str]]): Custom command for file processing. For some file formats we have default commands. If empty or None, the class will try to find a suitable command based on the file format and mode.
         If a command is provided, it will be used directly.
         nproc (int): Number of threads for multithreaded tools. Defaults to 1.
-        is_binary (bool): Indicates if the file should be opened in binary mode. Default is False.
 
     Methods:
         __call__(): Executes the command or opens the file based on the provided parameters. Return pairtools.lib.fileio.CommandRunResult object
@@ -116,7 +115,6 @@ class CommandFormatter():
     path: tp.Optional[str]=None
     command: tp.Optional[tp.Union[tp.List[str], str]]=None
     nproc: int=1
-    is_binary: bool=False
 
     @staticmethod
     def format_notfounderror(checked_tools: tp.List[str], mode: bool) -> str:
@@ -136,21 +134,15 @@ def format_notfounderror(checked_tools: tp.List[str], mode: bool) -> str:
 
     def __post_init__(self):
         """
-        Post-initialization modification of the command instructions.
-        Adds instructions for binary files, detects file extension, checks and picks the tools available in the system.
+        Auto-detect file extension, check and pick the tool available in the system.
         """
         self.__nocommand = False
 
-        # Add instruction for the binary files:
-        if self.is_binary:
-            self.file_mode = f'{self.mode}b'
-        else:
-            self.file_mode = self.mode
-
-        # If the command was provided by the user, simply run it, no urther modifications needed:
+        # If the command was provided by the user, simply run it, no further modifications needed:
         if self.command:
             return
         
+        # If no user-defined command was provided, detect the command automatically.
         # Get the file extension:
         self.__extension = self.path.split('.')[-1]
 
@@ -167,9 +159,20 @@ def __post_init__(self):
         # Next, iterate over possible tools. When the tool is found, constructs a command.
         checked_tools = []
         for possible_solution in PRESET_COMMANDS[(self.__extension, self.mode)]:
+            # Check for the presence of the tool:
             if shutil.which(possible_solution['tool']) is None:
                 checked_tools.append(possible_solution['tool'])
                 continue
+
+            # bgzip sometimes is outdated in the system, causing -@ option to crash. 
+            # we explicitly check bgzip version, and if it is not up-to-date, skip bgzip:
+            if possible_solution['tool']=='bgzip':
+                cmd_check = subprocess.Popen(shlex.split('bgzip --version'), stderr=subprocess.PIPE, text=True)
+                cmd_error = cmd_check.stderr.buffer.readline().decode()
+                if 'invalid' in cmd_error:
+                    checked_tools.append(possible_solution['tool'])
+                    continue
+
             self.command = possible_solution['command'].format(str(self.nproc))
             return
 
@@ -181,20 +184,26 @@ def __construct_process(self):
         Construct subprocess Popen object for a command, file path and file opening mode.
         """
 
-        # Split the command, if needed:
+        # Check if command is a string and contains shell operators like pipes
+        use_shell = False
         if isinstance(self.command, str):
-            command_split = shlex.split(self.command)
+            if '|' in self.command or '>' in self.command or '<' in self.command:
+                use_shell = True
+                command_exec = self.command
+            else:
+                command_exec = shlex.split(self.command)
         else:
-            command_split = self.command
+            # If already a list, assume no shell needed:
+            command_exec = self.command
 
         # Open the file:
-        self.__process_file = open(self.path, self.file_mode)
+        self.__process_file = open(self.path, self.mode)
 
         # Run Popen:
         if self.mode == 'r':
-            cmd = subprocess.Popen(command_split, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            cmd = subprocess.Popen(command_exec, stdin=self.__process_file, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=use_shell)
         else:
-            cmd = subprocess.Popen(command_split, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            cmd = subprocess.Popen(command_exec, stdout=self.__process_file, stdin=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=use_shell)
         
         return cmd
     
@@ -213,7 +222,7 @@ def __call__(self) -> CommandRunResult:
         # and (2) no command was provided by user.
         # We then simply open file in given mode and do not run any command on it:
         if self.__nocommand:
-            self.__process_file = open(self.path, self.file_mode)
+            self.__process_file = open(self.path, self.mode)
             return CommandRunResult(input=self.__process_file, errors=None, output=self.__process_file, mode=self.mode)
 
         process = self.__construct_process()
@@ -247,6 +256,35 @@ def auto_open(path, mode, nproc=1, command=None):
     return result.outfile
 
 
+def get_stream_handlers(instream):
+    """
+    Get the readline and peek functions for the provided input stream.
+
+    Parameters:
+        instream (file-like object): The input stream to get the handlers for.
+
+    Returns:
+        tuple: A tuple containing the following elements:
+            - readline_f (function): The readline function for the input stream.
+            - peek_f (function): The peek function for the input stream.
+
+    Raises:
+        ValueError: If the peek function cannot be found for the provided stream.
+    """
+    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
+
+
+#### Legacy code (consider removing):
+
 class PipedIO:
     def __init__(self, file_or_path, command, mode="r"):
         """
@@ -328,32 +366,3 @@ def close(self, timeout=None):
         self._stream.close()
         retcode = self._proc.wait(timeout=timeout)
         return retcode
-
-
-def get_stream_handlers(instream):
-    """
-    Get the readline and peek functions for the provided input stream.
-
-    Parameters:
-        instream (file-like object): The input stream to get the handlers for.
-
-    Returns:
-        tuple: A tuple containing the following elements:
-            - readline_f (function): The readline function for the input stream.
-            - peek_f (function): The peek function for the input stream.
-
-    Raises:
-        ValueError: If the peek function cannot be found for the provided stream.
-    """
-    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
-
-

From 6b599e54b8102d527ae5af254ebce16fa06731bc Mon Sep 17 00:00:00 2001
From: Aleksandra Galitsyna <agalitzina@gmail.com>
Date: Thu, 19 Jun 2025 08:55:48 -0400
Subject: [PATCH 14/15] examples scaling notebook checked for compatibility
 with pairtools fileio update

---
 .../pairtools_restrict_walkthrough.ipynb      | 172 +++++++++---------
 pairtools/lib/scaling.py                      |   2 +-
 2 files changed, 87 insertions(+), 87 deletions(-)

diff --git a/doc/examples/pairtools_restrict_walkthrough.ipynb b/doc/examples/pairtools_restrict_walkthrough.ipynb
index 56608fa9..2cc1431d 100644
--- a/doc/examples/pairtools_restrict_walkthrough.ipynb
+++ b/doc/examples/pairtools_restrict_walkthrough.ipynb
@@ -29,9 +29,6 @@
     "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"
@@ -64,7 +61,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 6,
    "id": "a3d3eafc-5c28-40d4-be2a-8c4ba23e9809",
    "metadata": {},
    "outputs": [
@@ -74,13 +71,13 @@
      "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"
+      "100   330  100   330    0     0   1289      0 --:--:-- --:--:-- --:--:--  1294\n",
+      "100 3395M  100 3395M    0     0  16.1M      0  0:03:30  0:03:30 --:--:-- 12.2M\n"
      ]
     }
    ],
    "source": [
-    "!curl -O -L --user RG6CSRMC:xlii3stnkphfygmu https://data.4dnucleome.org/files-processed/4DNFIW2BKSNF/@@download/4DNFIW2BKSNF.pairs.gz"
+    "!curl -O -L --user QFYXHTWC:w6vwvhawzees3byl https://data.4dnucleome.org/files-processed/4DNFIW2BKSNF/@@download/4DNFIW2BKSNF.pairs.gz"
    ]
   },
   {
@@ -124,8 +121,11 @@
    "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"
+    "# Digest the genome into restriction fragments.\n",
+    "# How to download the genome, follow general pairtools walkthrough:\n",
+    "# https://github.com/open2c/pairtools/blob/master/doc/examples/pairtools_walkthrough.ipynb\n",
+    "\n",
+    "cooler digest ~/.local/share/genomes/hg38/hg38.fa.sizes ~/.local/share/genomes/hg38/hg38.fa MboI > hg38.MboI.restricted.bed"
    ]
   },
   {
@@ -137,7 +137,7 @@
    "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"
+    "pairtools restrict -f hg38.MboI.restricted.bed 4DNFIW2BKSNF.pairs.sampled.gz -o 4DNFIW2BKSNF.pairs.sampled.restricted.gz"
    ]
   },
   {
@@ -191,14 +191,6 @@
     "df.columns = columns"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7688d530-4860-40e9-b865-affb7c35ccf1",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -223,20 +215,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 12,
    "id": "1a7ef073-082b-4aa6-972f-85ada84be4d4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 921.6x633.6 with 1 Axes>"
+       "<Figure size 900x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -245,8 +235,15 @@
     "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",
+    "plt.figure(figsize=[9,5])\n",
+    "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_left, \n",
+    "             bins=np.arange(xmin, xmax, step), \n",
+    "             label='Distance from the 5\\' read end to the nearest upstream rsite, + mapped reads',\n",
+    "             kde=False)\n",
+    "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_right, \n",
+    "             bins=np.arange(xmin, xmax, step), \n",
+    "             label='Distance from the 5\\' read end to the nearest downstream rsite, + mapped reads', \n",
+    "             kde=False)\n",
     "\n",
     "plt.xlim(xmin, xmax)\n",
     "plt.legend()\n",
@@ -255,20 +252,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 13,
    "id": "8fb2a16b-a921-4451-9250-4c0e381ac516",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 921.6x633.6 with 1 Axes>"
+       "<Figure size 900x500 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -277,8 +272,15 @@
     "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",
+    "plt.figure(figsize=[9,5])\n",
+    "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_left, \n",
+    "             bins=np.arange(xmin, xmax, step), \n",
+    "             label='Distance from the 5\\' read end to the nearest upstream rsite, + mapped reads',\n",
+    "             kde=False)\n",
+    "sns.distplot(df.query('strand1==\"+\"').dist_rfrag1_right, \n",
+    "             bins=np.arange(xmin, xmax, step), \n",
+    "             label='Distance from the 5\\' read end to the nearest downstream rsite, + mapped reads',\n",
+    "             kde=False)\n",
     "\n",
     "plt.xlim(xmin, xmax)\n",
     "plt.legend()\n",
@@ -295,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 14,
    "id": "97eac9b5-2b51-4529-9056-48d061c30d6b",
    "metadata": {},
    "outputs": [],
@@ -314,7 +316,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 15,
    "id": "28358a56-a6fe-4ec7-9ca6-52822a6224b9",
    "metadata": {},
    "outputs": [],
@@ -324,7 +326,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 16,
    "id": "3769c57b-78c7-48e4-85bf-710f7f459e1e",
    "metadata": {},
    "outputs": [],
@@ -367,24 +369,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 22,
    "id": "bf07b649-d184-4ded-827b-d8ff3f9f4284",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 921.6x633.6 with 1 Axes>"
+       "<Figure size 900x900 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
+    "plt.figure(figsize=[9,9])\n",
+    "\n",
     "# 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",
@@ -393,7 +395,7 @@
     "                regions=hg38_arms,\n",
     "                chromsizes=hg38_arms,\n",
     "                dist_range=(10, 1e9), \n",
-    "                n_dist_bins=128,\n",
+    "                n_dist_bins_decade=8,\n",
     "                chunksize=int(1e7),\n",
     "            )\n",
     "plot(cis_scalings_distant, n_distant, label=\"pairs, 5' distant from rsite\")\n",
@@ -407,7 +409,7 @@
     "                regions=hg38_arms,\n",
     "                chromsizes=hg38_arms,\n",
     "                dist_range=(10, 1e9), \n",
-    "                n_dist_bins=128,\n",
+    "                n_dist_bins_decade=8,\n",
     "                chunksize=int(1e7),\n",
     "            )\n",
     "plot(cis_scalings_toodistant, n_toodistant, label=\"pairs, 5' too far from rsite\")\n",
@@ -421,7 +423,7 @@
     "                regions=hg38_arms,\n",
     "                chromsizes=hg38_arms,\n",
     "                dist_range=(10, 1e9), \n",
-    "                n_dist_bins=128,\n",
+    "                n_dist_bins_decade=8,\n",
     "                chunksize=int(1e7),\n",
     "            )\n",
     "plot(cis_scalings_tooclose, n_tooclose, label=\"pairs, 5' close to rsite\")\n",
@@ -438,7 +440,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 23,
    "id": "bfb77fa0-85ee-4573-b745-57353b74f646",
    "metadata": {},
    "outputs": [],
@@ -459,7 +461,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 24,
    "id": "c6913bb4-f861-4098-a193-94a134df4ea5",
    "metadata": {},
    "outputs": [
@@ -467,14 +469,14 @@
      "data": {
       "text/plain": [
        "type_rfrag\n",
-       "DanglingEnd       76902\n",
-       "Mirror             3214\n",
-       "Regular pair    1132002\n",
-       "SelfCircle         3036\n",
+       "DanglingEnd       76703\n",
+       "Mirror             3225\n",
+       "Regular pair    1130730\n",
+       "SelfCircle         2953\n",
        "Name: readID, dtype: int64"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -485,20 +487,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 25,
    "id": "c2e77360-e8ee-43c6-8322-b9990aef19bc",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 921.6x633.6 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -511,7 +511,7 @@
     "                regions=hg38_arms,\n",
     "                chromsizes=hg38_arms,\n",
     "                dist_range=(10, 1e9), \n",
-    "                n_dist_bins=128,\n",
+    "                n_dist_bins_decade=8,\n",
     "                chunksize=int(1e7),\n",
     "            )\n",
     "plot(cis_scalings, n, label=\"pairs\")\n",
@@ -524,7 +524,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 26,
    "id": "a506a74c-230f-4219-9273-99b6f04e211d",
    "metadata": {},
    "outputs": [],
@@ -545,7 +545,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 27,
    "id": "255bda45-6a64-4795-a964-546e55d67145",
    "metadata": {},
    "outputs": [
@@ -553,14 +553,14 @@
      "data": {
       "text/plain": [
        "type_bydist\n",
-       "DanglingEnd      135381\n",
-       "Mirror            18383\n",
-       "Regular pair    1053213\n",
-       "SelfCircle         8177\n",
+       "DanglingEnd      134541\n",
+       "Mirror            18218\n",
+       "Regular pair    1052562\n",
+       "SelfCircle         8290\n",
        "Name: readID, dtype: int64"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -571,7 +571,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 28,
    "id": "b628bdfb-abbf-45df-8f33-2056dc96f19f",
    "metadata": {},
    "outputs": [
@@ -620,31 +620,31 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>DanglingEnd</th>\n",
-       "      <td>76898</td>\n",
+       "      <td>76703</td>\n",
+       "      <td>0</td>\n",
        "      <td>0</td>\n",
-       "      <td>4</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Mirror</th>\n",
        "      <td>0</td>\n",
-       "      <td>3176</td>\n",
-       "      <td>38</td>\n",
+       "      <td>3163</td>\n",
+       "      <td>62</td>\n",
        "      <td>0</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Regular pair</th>\n",
-       "      <td>58483</td>\n",
-       "      <td>15207</td>\n",
-       "      <td>1052994</td>\n",
-       "      <td>5318</td>\n",
+       "      <td>57838</td>\n",
+       "      <td>15055</td>\n",
+       "      <td>1052356</td>\n",
+       "      <td>5481</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>SelfCircle</th>\n",
        "      <td>0</td>\n",
        "      <td>0</td>\n",
-       "      <td>177</td>\n",
-       "      <td>2859</td>\n",
+       "      <td>144</td>\n",
+       "      <td>2809</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -654,13 +654,13 @@
        "                  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"
+       "DanglingEnd        76703      0            0          0\n",
+       "Mirror                 0   3163           62          0\n",
+       "Regular pair       57838  15055      1052356       5481\n",
+       "SelfCircle             0      0          144       2809"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 28,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -687,9 +687,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.10",
+   "display_name": "test",
    "language": "python",
-   "name": "python310"
+   "name": "test"
   },
   "language_info": {
    "codemirror_mode": {
@@ -701,7 +701,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
diff --git a/pairtools/lib/scaling.py b/pairtools/lib/scaling.py
index c9a59577..772c163e 100644
--- a/pairtools/lib/scaling.py
+++ b/pairtools/lib/scaling.py
@@ -358,7 +358,7 @@ def compute_scaling(
         Additional dataframe with chromosome sizes, if different from regions.
     dist_range : tuple of int, optional
         The range of distances to calculate the scaling curve. Default is (10, 1000000000).
-    n_dist_bins : int, optional
+    n_dist_bins_decade : int, optional
         The number of distance bins per order of magnitude in a log10-space. Default is 8.
     chunksize : int, optional
         Size of chunks for calculations. Default is 10000000.

From 4d05568d255e016f3ad4dbe73bf965b8806f2c76 Mon Sep 17 00:00:00 2001
From: Aleksandra Galitsyna <agalitzina@gmail.com>
Date: Thu, 19 Jun 2025 09:14:58 -0400
Subject: [PATCH 15/15] piping IO for filesio fixed.i Pairtools walkthrough
 checked for compatibility.

---
 doc/examples/pairtools_walkthrough.ipynb | 151 +++++++++++------------
 pairtools/lib/fileio.py                  |  39 +++---
 2 files changed, 90 insertions(+), 100 deletions(-)

diff --git a/doc/examples/pairtools_walkthrough.ipynb b/doc/examples/pairtools_walkthrough.ipynb
index 97caba46..34d28737 100644
--- a/doc/examples/pairtools_walkthrough.ipynb
+++ b/doc/examples/pairtools_walkthrough.ipynb
@@ -56,17 +56,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "571e94fb-3dec-4042-9e21-6c39802ed8df",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SRR13849430_1.fastq.gz\tSRR13849430_2.fastq.gz\n"
+     ]
+    }
+   ],
    "source": [
     "! ls SRR13849430*.fastq.gz"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "e9fb044d-1ba0-48c7-b40a-99d033518e43",
    "metadata": {},
    "outputs": [
@@ -126,7 +134,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Install hg38 genome by genomepy:\n",
+    "# Install hg38 genome by genomepy, it might take some time to compile the bwa index for hg38:\n",
     "! genomepy install hg38"
    ]
   },
@@ -186,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "955bcafa-e521-4627-8c8b-94e05e46e6b8",
    "metadata": {},
    "outputs": [
@@ -194,10 +202,10 @@
      "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<JJJF-J<FFF-A7-A-7<FF-JF-JFA-AJJJJAJJJJ<FAFJ<JJFJJF7FJJF7JFFJJ-<-FJJAJA-JJJ7JF-A7AFFFFFFAJJJFJJJJAJAJJJJJJJJJJJFFAA#\tNM:i:1\tMD:Z:96G0\tAS:i:96\tXS:i:21\n",
-      "SRR13849430.1\t181\tchr12\t78795720\t0\t*\t=\t78795720\t0\tTTATATGCTGACGTCGTCCATTGTTGATTCTTTGTGGTCTGTGTTCCCTCTGAAGCTCTCTGTACTTGTATATACAATTAGGCACCAACAATTCAACATGGGTAGTTATTATACTGCTAAAGCGACCCCAGAGCGAACCGGGCTACCTTN\t---7---7-7)))-7---7-----7-7<---7-)<)<-----)-)<77--7---)7-<7-7----A-F<<-AF7-A777--77-7-----7--<--7-F777-A7-7---<7--7<7-<--77-77--77--7-7A---7-7---FF<A#\tMC:Z:53S97M\tAS:i:0\tXS:i:0\n",
-      "SRR13849430.2\t73\tchr8\t43879758\t60\t75M75S\t=\t43879758\t0\tNAAAAGGTTTATCTCTGTGAGATGAAGCCACATAAAACCAAGCAGTTTCACAGAAACTTGTTTGTAGATTTTAAATCCGCACATCACAAAGCCATTTCACAGACAGCTTCTTTCTACTTTTTATCTGCGGCCCTTCCGTATTCCCGCATA\t#AAFAJJFJJJJFAAFJA<JJJFJJFJJJJJFFJ-FF<FFJJJJJJ7AFFF<FJJ-<-F7<7<A-AF7AJAJ-A-7FF7JJJFJJFJJFFFFAJFJJ7-7-A-F--777FJFJF7---AAAF<AAA--))--))-<))-------)))7-\tNM:i:2\tMD:Z:0A58C15\tAS:i:69\tXS:i:29\tSA:Z:chr8,43877720,+,73S54M23S,44,1;\n",
-      "SRR13849430.2\t2121\tchr8\t43877720\t44\t73H54M23H\t=\t43877720\t0\tAATCCGCACATCACAAAGCCATTTCACAGACAGCTTCTTTCTACTTTTTATCTG\tA-7FF7JJJFJJFJJFFFFAJFJJ7-7-A-F--777FJFJF7---AAAF<AAA-\tNM:i:1\tMD:Z:5A48\tAS:i:49\tXS:i:35\tSA:Z:chr8,43879758,+,75M75S,60,2;\n"
+      "SRR13849430.1\t121\tchr12\t78795720\t60\t53S97M\t=\t78795720\t0\tCAAATACTACAAAGAATAACATCAGGGAGTTGTCAGCATATAAACTATTTTTAGATCTGGATAAAGGAAGAAAGCAGGTACAAAAGTCCCTTGCTAAAGCAGAATTTAGAGCAAGGTCCCAACTCTCTTCTATCTTATAAAGGCTGAGAN\t-7-7---A------7--77--))))7--F-A)7F<JJJF-J<FFF-A7-A-7<FF-JF-JFA-AJJJJAJJJJ<FAFJ<JJFJJF7FJJF7JFFJJ-<-FJJAJA-JJJ7JF-A7AFFFFFFAJJJFJJJJAJAJJJJJJJJJJJFFAA#\tNM:i:1\tMD:Z:96G0\tMQ:i:0\tAS:i:96\tXS:i:21\n",
+      "SRR13849430.1\t181\tchr12\t78795720\t0\t*\t=\t78795720\t0\tTTATATGCTGACGTCGTCCATTGTTGATTCTTTGTGGTCTGTGTTCCCTCTGAAGCTCTCTGTACTTGTATATACAATTAGGCACCAACAATTCAACATGGGTAGTTATTATACTGCTAAAGCGACCCCAGAGCGAACCGGGCTACCTTN\t---7---7-7)))-7---7-----7-7<---7-)<)<-----)-)<77--7---)7-<7-7----A-F<<-AF7-A777--77-7-----7--<--7-F777-A7-7---<7--7<7-<--77-77--77--7-7A---7-7---FF<A#\tMC:Z:53S97M\tMQ:i:60\tAS:i:0\tXS:i:0\n",
+      "SRR13849430.2\t73\tchr8\t43879758\t60\t75M75S\t=\t43879758\t0\tNAAAAGGTTTATCTCTGTGAGATGAAGCCACATAAAACCAAGCAGTTTCACAGAAACTTGTTTGTAGATTTTAAATCCGCACATCACAAAGCCATTTCACAGACAGCTTCTTTCTACTTTTTATCTGCGGCCCTTCCGTATTCCCGCATA\t#AAFAJJFJJJJFAAFJA<JJJFJJFJJJJJFFJ-FF<FFJJJJJJ7AFFF<FJJ-<-F7<7<A-AF7AJAJ-A-7FF7JJJFJJFJJFFFFAJFJJ7-7-A-F--777FJFJF7---AAAF<AAA--))--))-<))-------)))7-\tNM:i:2\tMD:Z:0A58C15\tMQ:i:0\tAS:i:69\tXS:i:29\tSA:Z:chr8,43877720,+,73S54M23S,44,1;\n",
+      "SRR13849430.2\t2121\tchr8\t43877720\t44\t73H54M23H\t=\t43877720\t0\tAATCCGCACATCACAAAGCCATTTCACAGACAGCTTCTTTCTACTTTTTATCTG\tA-7FF7JJJFJJFJJFFFFAJFJJ7-7-A-F--777FJFJF7---AAAF<AAA-\tNM:i:1\tMD:Z:5A48\tMQ:i:0\tAS:i:49\tXS:i:35\tSA:Z:chr8,43879758,+,75M75S,60,2;\n"
      ]
     }
    ],
@@ -254,7 +262,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "e96be112-96d6-4c30-9453-c84f5a1b5edd",
    "metadata": {},
    "outputs": [
@@ -278,7 +286,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "447ca568-4232-4242-80b3-526e6c886e45",
    "metadata": {},
    "outputs": [
@@ -286,10 +294,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "#samheader: @SQ\tSN:chrX\tLN:156040895\n",
-      "#samheader: @SQ\tSN:chrY\tLN:57227415\n",
-      "#samheader: @PG\tID:bwa\tPN:bwa\tVN:0.7.17-r1188\tCL:./bwa mem -t 5 -SP /home/agalicina/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz\n",
-      "#samheader: @PG\tID:pairtools_parse\tPN:pairtools_parse\tCL:./pairtools parse -o test.pairs.gz -c /home/agalicina/.local/share/genomes/hg38/hg38.fa.sizes --drop-sam --drop-seq --output-stats test.stats --assembly hg38 --no-flip --add-columns mapq --walks-policy mask test.bam\tPP:bwa\tVN:1.0.0-dev1\n",
+      "#samheader: @SQ\tSN:chrY_KI270740v1_random\tLN:37240\n",
+      "#samheader: @HD\tVN:1.5\tSO:unsorted\tGO:query\n",
+      "#samheader: @PG\tID:bwa\tPN:bwa\tVN:0.7.18-r1243-dirty\tCL:bwa mem -t 5 -SP /home/agalicina/.local/share/genomes/hg38/index/bwa/hg38.fa SRR13849430_1.fastq.gz SRR13849430_2.fastq.gz\n",
+      "#samheader: @PG\tID:pairtools_parse\tPN:pairtools_parse\tCL:/home/agalicina/anaconda3/envs/test/bin/pairtools parse -o test.pairs.gz -c /home/agalicina/.local/share/genomes/hg38/hg38.fa.sizes --drop-sam --drop-seq --output-stats test.stats --assembly hg38 --no-flip --add-columns mapq --walks-policy mask test.bam\tPP:bwa\tVN:1.1.3\n",
       "#columns: readID chrom1 pos1 chrom2 pos2 strand1 strand2 pair_type mapq1 mapq2\n"
      ]
     }
@@ -302,7 +310,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "afcfeeeb-1502-4b45-b614-24af74b70593",
    "metadata": {},
    "outputs": [
@@ -381,12 +389,12 @@
     "            --output-sam test.dups.bam \\\n",
     "         ) \\\n",
     "    --output-stats test.dedup.stats \\\n",
-    "    test.pairs.gz"
+    "    test.sorted.pairs.gz"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "d9aaceeb-1a88-4c24-9fc2-3f44069715a1",
    "metadata": {},
    "outputs": [
@@ -394,16 +402,16 @@
      "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"
+      "SRR13849430.4544778\tchr1\t136880\tchr1\t134881\t+\t+\tUR\t28\t3\n",
+      "SRR13849430.4112679\tchr1\t136992\tchr1\t136650\t-\t+\tUU\t17\t12\n",
+      "SRR13849430.1113517\tchr1\t599102\tchr1\t599228\t+\t-\tUU\t22\t22\n",
+      "SRR13849430.1262300\tchr1\t656693\tchr1\t886234\t+\t-\tUU\t5\t60\n",
+      "SRR13849430.2778343\tchr1\t760774\tchr1\t808155\t-\t+\tUU\t6\t21\n",
+      "SRR13849430.3231567\tchr1\t777267\tchr1\t35948382\t+\t-\tUU\t32\t60\n",
+      "SRR13849430.4836373\tchr1\t778257\tchr1\t777890\t-\t+\tUU\t8\t48\n",
+      "SRR13849430.1256119\tchr1\t785664\tchr1\t954301\t+\t+\tUU\t60\t60\n",
+      "SRR13849430.2390636\tchr1\t788677\tchr1\t22439216\t-\t+\tUU\t8\t60\n",
+      "SRR13849430.3622660\tchr1\t788734\tchr1\t822206\t+\t-\tRU\t60\t26\n"
      ]
     }
    ],
@@ -415,7 +423,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "ca3e27a7-7905-46b2-8ad4-245c28f01102",
    "metadata": {},
    "outputs": [
@@ -423,16 +431,16 @@
      "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"
+      "SRR13849430.2781007\tchr1\t760774\tchr1\t808155\t-\t+\tDD\t6\t20\n",
+      "SRR13849430.1103881\tchr1\t855594\tchr1\t856474\t+\t-\tDD\t42\t47\n",
+      "SRR13849430.3637378\tchr1\t860367\tchr1\t863893\t-\t-\tDD\t50\t42\n",
+      "SRR13849430.3708228\tchr1\t860367\tchr1\t863893\t-\t-\tDD\t50\t43\n",
+      "SRR13849430.1681017\tchr1\t904370\tchr1\t952493\t-\t-\tDD\t60\t60\n",
+      "SRR13849430.4712708\tchr1\t912376\tchr1\t913168\t-\t-\tDD\t60\t60\n",
+      "SRR13849430.169202\tchr1\t920729\tchr1\t929007\t-\t+\tDD\t60\t60\n",
+      "SRR13849430.1735365\tchr1\t929632\tchr1\t925420\t+\t+\tDD\t60\t60\n",
+      "SRR13849430.1743119\tchr1\t929632\tchr1\t925420\t+\t+\tDD\t60\t60\n",
+      "SRR13849430.1755818\tchr1\t929632\tchr1\t925420\t+\t+\tDD\t60\t60\n"
      ]
     }
    ],
@@ -492,7 +500,9 @@
    "id": "ca2c1c56-9024-4fa0-abb9-ed1f9ab313f1",
    "metadata": {},
    "source": [
-    "### MultiQC"
+    "### MultiQC\n",
+    "\n",
+    "To make a nice HTML with pairs stats, install Open2C version of multiQC from:  https://github.com/open2c/MultiQC"
    ]
   },
   {
@@ -512,33 +522,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "d76bd76c-f0f5-4921-b873-9390e715eab9",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "\n",
-       "        <iframe\n",
-       "            width=\"1200\"\n",
-       "            height=\"700\"\n",
-       "            src=\"./multiqc_report.html\"\n",
-       "            frameborder=\"0\"\n",
-       "            allowfullscreen\n",
-       "            \n",
-       "        ></iframe>\n",
-       "        "
-      ],
-      "text/plain": [
-       "<IPython.lib.display.IFrame at 0x7f78f42cfc70>"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
    "source": [
     "from IPython.display import IFrame\n",
     "\n",
@@ -606,7 +595,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 11,
    "id": "1839183d-4d5c-4b29-926c-0d56e00c8b8a",
    "metadata": {},
    "outputs": [],
@@ -624,7 +613,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "7bae233c-36f2-483c-8957-766e200739a4",
    "metadata": {},
    "outputs": [],
@@ -634,7 +623,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "id": "2b4cc40b-5aaf-4db8-b870-ba190fdb5d01",
    "metadata": {},
    "outputs": [],
@@ -644,7 +633,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 14,
    "id": "4350d8c1-b50c-43f7-92e5-43802122320b",
    "metadata": {},
    "outputs": [],
@@ -657,7 +646,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 15,
    "id": "cd823dec-49c8-46e0-96b6-dcb0344f9d9c",
    "metadata": {},
    "outputs": [],
@@ -677,32 +666,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 20,
    "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",
+    "chrom_start, chrom_end = clr.chromnames.index('chr10'), clr.chromnames.index('chr11')\n",
     "start, end = chromstarts[chrom_start], chromstarts[chrom_end]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": 21,
    "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": [
-       "<Figure size 936x720 with 4 Axes>"
+       "<Figure size 1300x1000 with 4 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -722,7 +709,7 @@
     "plt.colorbar(im, ax=ax ,fraction=0.046, pad=0.04, label='chr1');\n",
     "\n",
     "ax = axs[1]\n",
-    "ax.set_title('Chromosomes 3-5')\n",
+    "ax.set_title('Chromosomes 10-11')\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(np.array(chromstarts[chrom_start:chrom_end])-start, clr.chromnames[chrom_start:chrom_end], rotation=90);\n",
@@ -736,7 +723,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "e07ca165-15ed-459c-af7b-3156de81f935",
+   "id": "cb10fb95-594b-48e3-9337-72bca28c88f7",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -758,7 +745,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.8"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
diff --git a/pairtools/lib/fileio.py b/pairtools/lib/fileio.py
index 99efccd5..e00b1a8c 100644
--- a/pairtools/lib/fileio.py
+++ b/pairtools/lib/fileio.py
@@ -102,7 +102,7 @@ class CommandFormatter():
 
     Attributes:
         mode (str): Mode in which the file is to be opened ('r', 'w', or 'a').
-        path (Optional[str]): Path to the target file. Empty or '-' indicates standard input/output (for || case).
+        path (Optional[str]): Path to the target file. Empty (None) or '-' indicates standard input/output (for the case of piping).
         command (Optional[Union[List[str], str]]): Custom command for file processing. For some file formats we have default commands. If empty or None, the class will try to find a suitable command based on the file format and mode.
         If a command is provided, it will be used directly.
         nproc (int): Number of threads for multithreaded tools. Defaults to 1.
@@ -116,22 +116,6 @@ class CommandFormatter():
     command: tp.Optional[tp.Union[tp.List[str], str]]=None
     nproc: int=1
 
-    @staticmethod
-    def format_notfounderror(checked_tools: tp.List[str], mode: bool) -> str:
-        """
-        Format a neat error message, used in case when none tools were found in the system.
-        """
-        text_task = 'read input file' if mode=='r' else 'write input file'
-        if len(checked_tools)==0:
-            raise ValueError('Something went wrong while IO operations. None tools were checked.')
-        elif len(checked_tools)==1:
-            text_verb = 'is'
-            text_tools = checked_tools[0]
-        else:
-            text_verb = 'are'
-            text_tools = f'{"", "".join(checked_tools[:-1])} and {checked_tools[-1]}'
-        return f"{text_tools} {text_verb} not found, cannot {text_task}"
-
     def __post_init__(self):
         """
         Auto-detect file extension, check and pick the tool available in the system.
@@ -144,7 +128,10 @@ def __post_init__(self):
         
         # If no user-defined command was provided, detect the command automatically.
         # Get the file extension:
-        self.__extension = self.path.split('.')[-1]
+        if not self.path or self.path == '-':
+            self.__extension = ''
+        else:
+            self.__extension = self.path.split('.')[-1]
 
         # If extension is not in the keys of PRESET_EXT2MODE, 
         # simply return opened file in a given mode
@@ -179,6 +166,22 @@ def __post_init__(self):
         # No suitable command was found in the system, raise and format an error message.
         raise ValueError(self.format_notfounderror(checked_tools, self.mode=='r'))
 
+    @staticmethod
+    def format_notfounderror(checked_tools: tp.List[str], mode: bool) -> str:
+        """
+        Format a neat error message, used in case when none tools were found in the system.
+        """
+        text_task = 'read input file' if mode=='r' else 'write input file'
+        if len(checked_tools)==0:
+            raise ValueError('Something went wrong while IO operations. None tools were checked.')
+        elif len(checked_tools)==1:
+            text_verb = 'is'
+            text_tools = checked_tools[0]
+        else:
+            text_verb = 'are'
+            text_tools = f'{"", "".join(checked_tools[:-1])} and {checked_tools[-1]}'
+        return f"{text_tools} {text_verb} not found, cannot {text_task}"
+    
     def __construct_process(self):
         """
         Construct subprocess Popen object for a command, file path and file opening mode.