diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e443ffb
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+/test_data
+/build
+/ATaRVa.egg-info
+/ATARVA/__pycache__
+.DS_store
\ No newline at end of file
diff --git a/ATARVA/amplicon_read.py b/ATARVA/amplicon_read.py
new file mode 100644
index 0000000..f282304
--- /dev/null
+++ b/ATARVA/amplicon_read.py
@@ -0,0 +1,24 @@
+
+
+def check_flank(cooper, read, locus_start, locus_end):
+    flank = cooper.args.flank
+    enough_soft_flank = False
+    left_flank = None; right_flank = None
+
+    # read alignment covers the locus with enough soft clipped flanks on both sides
+    if read.ref_start < locus_start - flank and read.ref_end > locus_end + flank:
+        enough_soft_flank = True
+        left_flank  = flank
+        right_flank = flank
+
+    # for upstream soft_clip, checking the length compared to flank length
+    elif locus_start < read.ref_start:
+        mod_locus_start = read.ref_start
+        left_flank = min(flank, locus_start - read.ref_start)
+
+    # for downstream soft_clip, checking the length compared to flank length
+    elif locus_end > read.ref_end:
+        mod_locus_end = read.ref_end
+        right_flank = min(flank, read.ref_end - locus_end)
+
+    return enough_soft_flank, left_flank, right_flank
\ No newline at end of file
diff --git a/ATARVA/baseline.py b/ATARVA/baseline.py
index 4772ae3..8b2dfe4 100644
--- a/ATARVA/baseline.py
+++ b/ATARVA/baseline.py
@@ -1,508 +1,525 @@
-from ATARVA.locus_utils import process_locus
-from ATARVA.cstag_utils import parse_cstag
-from ATARVA.cigar_utils import parse_cigar_tag
-from ATARVA.operation_utils import update_homopolymer_coords
-from ATARVA.genotype_utils import analyse_genotype
-from ATARVA.vcf_writer import *
-
+import numpy as np
 import pysam
-import sys
-import logging
-
-def locus_processor(global_loci_keys, global_loci_ends, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, ref, Chrom, global_loci_info, out, snpQ, snpC, snpD, snpR, phasingR, tbx, flank, sorted_global_ins_rpos_set, log_bool, logger, male):
-
-    genotyped_loci = 0
-    popped    = global_loci_ends.pop(0)
-    locus_key = global_loci_keys.pop(0)
-    lstart = int(locus_key[locus_key.index(':')+1 : locus_key.index('-')])
-    lend = int(locus_key[locus_key.index('-')+1:])
-    near_by_loci = []
-    for row in tbx.fetch(Chrom, lstart-flank, lend+flank):
-        row = row.split('\t')
-        near_by_loci.append( ( int(row[1]), int(row[2]) ) )
-
-    if locus_key in global_loci_variations:
-        
-
-        if sorted_global_snp_list == []:
-            sorted_global_snp_list = sorted(list(global_snp_positions.keys()))
-        
-
-        prev_reads, homozygous, ambiguous, homozygous_allele, reads_of_homozygous, hallele_counter, skip_point, max_limit = process_locus(locus_key, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, global_loci_info, near_by_loci, sorted_global_ins_rpos_set, Chrom, lstart, lend, ref, log_bool, logger)
-
-        if homozygous:
-            vcf_homozygous_writer(ref, Chrom, locus_key, global_loci_info, homozygous_allele, global_loci_variations, len(reads_of_homozygous), out, reads_of_homozygous)
-            genotyped_loci += 1
-        elif ambiguous:
-            state, skip_point = analyse_genotype(Chrom, locus_key, global_loci_info, global_loci_variations, global_read_variations, global_snp_positions, hallele_counter, ref, out, sorted_global_snp_list, snpQ, snpC, snpD, snpR, phasingR, maxR, max_limit, male)
-            if state: genotyped_loci += 1
-            elif skip_point == 0: print('Locus skipped due to insignificant snps at the level of read split.')
-            elif skip_point == 1: print('Locus skipped due to less read contribution of Significant snps.')
-            elif skip_point == 2: print('Locus skipped due to less read contribution in the phased clusters.')
-            elif skip_point == 6: print(f'Locus {locus_key} skipped due to wide distribution of alleles with one read supporting to it.') # add vcf_fail_writer with new FILTER tag
-            else: print('Locus  skipped due to less number of significant snps based on user\'s parameter.')
-        else:
-            if skip_point == 0:
-                # print('Locus skipped due to minimum number of supporting reads')
-                vcf_fail_writer(Chrom, locus_key, global_loci_info, ref, out, len(prev_reads), skip_point)
-            # else:
-            #     print('Locus skipped due to maximum number of supporting reads')
-                
-        del global_loci_variations[locus_key]
-        
-    return genotyped_loci
-
-# def flank_adjustment(loci_coords, exact_loci_coords, right_flank_list, left_flank_list): # incorrect code
-#     # Adjusting flanks based on the nearby repeat region
-#     for idx,locus in enumerate(loci_coords):
-#         current_left = left_flank_list[idx]
-#         current_right = right_flank_list[idx]
-#         new_left_flanks = []
-#         new_right_flanks = []
-#         for exact_locus in exact_loci_coords:
-#             if exact_locus[0]>locus[1]: break
-#             elif locus[1]>exact_locus[0]:  # after skipping locus (or) after came across the current locus, adjust the right flank dist
-#                 new_right_flanks.append(locus[1]-exact_locus[0] if (locus[1]-exact_locus[0]) < current_right else current_right)
-#             elif locus[0]<exact_locus[1]: # adjust the left flank dist
-#                 new_left_flanks.append(exact_locus[1] - locus[0] if (exact_locus[1] - locus[0]) < current_left else current_left) # add adjusted left flank dist for each overlapping exact repeat regions with cureent repeat region's flank on left. Zero is not to adjust any dist 
-#         if new_left_flanks!=[]:
-#             left_flank_list[idx] -= max(new_left_flanks) # take the max value of adjusted value, so that it wont affect other exact repeats
-#         if new_right_flanks!=[]:
-#             right_flank_list[idx] -= max(new_right_flanks) # take the max value of adjusted value, so that it wont affect other exact repeats
-
-#     return [right_flank_list, left_flank_list]
-
-def flank_adjustment(loci_coords, exact_loci_coords, right_flank_list, left_flank_list, tracker_idx):
-    # Adjusting flanks based on the nearby repeat region
-    for idx,locus in enumerate(loci_coords):
-        current_left = left_flank_list[idx]
-        current_right = right_flank_list[idx]
-        new_left_flanks = []
-        new_right_flanks = []
-        tr_idx = tracker_idx[idx]
-        for e_idx,exact_locus in enumerate(exact_loci_coords):
-            if exact_locus[0]>locus[1]:
-                break
-            if e_idx == tr_idx:
-                continue
-            if (e_idx>tr_idx) and (locus[1]>exact_locus[0]):  # after skipping locus (or) after came across the current locus, adjust the right flank dist
-                new_right_flanks.append(locus[1]-exact_locus[0] if (locus[1]-exact_locus[0]) < current_right else current_right)
-            if (e_idx<tr_idx) and (locus[0]<exact_locus[1]): # adjust the left flank dist
-                new_left_flanks.append(exact_locus[1] - locus[0] if (exact_locus[1] - locus[0]) < current_left else current_left) # add adjusted left flank dist for each overlapping exact repeat regions with cureent repeat region's flank on left. Zero is not to adjust any dist 
-        if new_left_flanks!=[]:
-            left_flank_list[idx] -= max(new_left_flanks) # take the max value of adjusted value, so that it wont affect other exact repeats
-        if new_right_flanks!=[]:
-            right_flank_list[idx] -= max(new_right_flanks) # take the max value of adjusted value, so that it wont affect other exact repeats
-
-    return [right_flank_list, left_flank_list]
-
-
-def cooper(bam_file, tbx_file, ref_file, aln_format, contigs, mapq_threshold, outfile, seq_tech, snpQ, snpC, snpD, maxR, minR, snpR, phasingR, tidx, flank, log_bool, karyotype):
-    # this function iterates through each contig and processes the genotypes for each locus
-    tbx  = pysam.Tabixfile(tbx_file)
-    bam  = pysam.AlignmentFile(bam_file, aln_format)
-    ref  = pysam.FastaFile(ref_file)
-
-    logger = 0
-    if tidx!=-1:
-        if tidx==0:
-            out = open(f'{outfile}.vcf', 'w')
-            vcf_writer(out, bam, bam_file.split("/")[-1].split('.')[0])
-            log_name = f'{outfile}_debug.log'
+import sys, os, logging
+
+from pathlib import Path
+from tqdm import tqdm
+from sortedcontainers import SortedList
+from collections import deque
+import cstag
+
+from ATARVA.structures        import ReadLocusInfo, LocusInfo, ReadInfo, LocusVariation, ExtendedRead
+from ATARVA.vcf_writer        import vcf_writer, write_homozygous_call, write_heterozygous_call, write_fail_call
+from ATARVA.operation_utils   import record_homopolymers, clean_eqsign_readseq
+from ATARVA.cstag_utils       import parse_cstag
+from ATARVA.cigar_utils       import parse_cigar
+from ATARVA.sub_operation_utils import mm_tag_extract, calculate_methylation
+from ATARVA.locus_utils       import process_locus
+from ATARVA.consensus         import consensus_seq_poa
+from ATARVA.genotype_utils    import analyse_genotype
+from ATARVA.process_softclips import process_softclips
+
+
+SKIP_MESSAGES = {
+    0: 'Locus failed - insufficient reads support',
+    1: 'Locus failed - insufficient reads for haplogroup',
+    6: 'Locus skipped - the locus is not a repetitive sequence.'
+}
+
+
+def _hidden_path(out_file):
+    """Return a hidden-file-prefixed path for thread output files."""
+    path = Path(out_file)
+    return str(path.parent / f'.{path.name}')
+
+
+class PysamWarningCapture:
+    """
+    Context manager to capture pysam/htslib C-level stderr warnings
+    and redirect them to a log file.
+    """
+
+    def __init__(self, logfile: str):
+        self.logfile    = logfile
+        self.log_fd     = None
+        self.old_stderr = None
+
+    def __enter__(self):
+        self.log_fd     = open(self.logfile, 'a')
+        self.old_stderr = os.dup(2)                    # save original stderr fd
+        os.dup2(self.log_fd.fileno(), 2)               # redirect fd 2 → log file
+        return self
+
+    def __exit__(self, *args):
+        sys.stderr.flush()
+        os.dup2(self.old_stderr, 2)                    # restore original stderr
+        os.close(self.old_stderr)
+        self.log_fd.close()
+
+
+class Cooper:
+    """
+    Independently handles genotyping a set of regions from a single BAM file.
+    """
+
+    def __init__(self, bam_file, region_ranges, args, out_file, sample_idx, thread_idx):
+        """
+        initialise Cooper and run genotyping.
+
+        :param bam_file:      path to BAM/CRAM/SAM file
+        :param region_ranges: list of (chrom, (start1,end1), (start2,end2)) tuples
+        :param args:          parsed command-line arguments
+        :param out_file:      output file base path
+        :param sample_idx:    index of sample in BAM list
+        :param thread_idx:    thread index (-1 = single-thread mode)
+        """
+
+        self.terminal_stderr = os.fdopen(os.dup(2), 'w')
+
+        # --- output paths ---
+        is_primary = thread_idx in (-1, 0)
+        if is_primary:
+            self.outfile = f'{out_file}.vcf'
+            self.logfile = f'{out_file}_debug.log'
         else:
-            out = open(f'{outfile}_thread_{tidx}.vcf', 'w')
-            log_name = f'{outfile}_debug_{tidx}.log'
-
-    else:
-        out = open(f'{outfile}.vcf', 'w')
-        vcf_writer(out, bam, bam_file.split("/")[-1].split('.')[0])
-        log_name = f'{outfile}_debug.log'
-
-    if log_bool:
-        with open(log_name, 'w'):
-            pass
-        logging.basicConfig(
-            filename=log_name,
-            level=logging.DEBUG,
-            format='%(levelname)s - %(message)s'
-        )
-        logger = logging.getLogger("MyLogger")
-    
-    for contig in contigs:
-
-        Chrom, Start, End = contig
-        male = False
-        if (Chrom in {'chrX', 'chrY', 'X', 'Y'}) and karyotype: male = True
-
-        # print(f"\nProcessing contig {contig}..\n", file=sys.stderr)
-        total_loci = 0
-        end_coord = 0
-        genotyped_loci_count = 0
-        for row in tbx.fetch(Chrom, Start[0], End[1]):
-            row = row.split('\t')
-            if (total_loci == 0) and (int(row[2]) != Start[1]): continue
-            total_loci += 1
-            end_coord = int(row[2])
-            if End[0] == int(row[1]): break
-        print(f"> {Chrom} {Start} {End} Total loci = ", total_loci, file=sys.stderr)
-
-        homozygous = False
-        ambiguous = False
-
-        global_snp_positions = dict()       # tracking the encountered SNPs
-        global_read_variations = {}         # tracking the variations on each read
-        global_loci_variations = {}         # tracking the variation for each locus
-        global_loci_info = {}               # saving the information of each loci
-
-        # tracking the loci
-        global_loci_ends = []; global_loci_keys    = []        
-        global_read_ends = []; global_read_indices = []
-
-        prev_reads = set()
-        sorted_global_snp_list = []
-        sorted_global_ins_rpos_set = set()
-
-        read_index = 0
-        for read in bam.fetch(Chrom, Start[0], End[1]):
-        
-
-            # skip read with low mapping quality
-            if read.mapping_quality < mapq_threshold:
-                continue
-
-            read_chrom = read.reference_name
-            read_start = read.reference_start
-            read_end   = read.reference_end
-
-            while len(global_loci_ends) > 0 and read_start > global_loci_ends[0]:
-
-                genotyped_loci_count += locus_processor(global_loci_keys, global_loci_ends, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, ref, Chrom, global_loci_info, out, snpQ, snpC, snpD, snpR, phasingR, tbx, flank, sorted_global_ins_rpos_set, log_bool, logger, male)
-                
-
-            while len(global_read_ends) > 0 and read_start > global_read_ends[0]:
-                # if the read is beyond the end of the first read that was tracked
-                if len(global_loci_ends) > 0 and global_read_ends[0] > global_loci_ends[0]:
-                    # if the initial read useful for the first locus being tracked then it is retained
-                    break
-                else:
-
-                    # remove the read information if the current read is beyond the first read and the locus
-                    popped = global_read_ends.pop(0)
-                    rindex = global_read_indices.pop(0)
-                    if rindex in global_read_variations:
-                        for pos in global_read_variations[rindex]['snps']:
-                            if pos in global_snp_positions:
-                                global_snp_positions[pos]['cov'] -= 1
-                        del_snps = []
-                        for pos in global_snp_positions: #!! modify this to terminate iteration after some condition
-                            if global_snp_positions[pos]['cov'] == 0:
-                                del_snps.append(pos)
-                                sorted_global_snp_list.remove(pos)
-                        for snp in del_snps:
-                            del global_snp_positions[snp]
-                        del global_read_variations[rindex]
-                        del del_snps
-
-                        if rindex in prev_reads: prev_reads.remove(rindex)
-                    del_ins_pos_idx = 0
-                    list_rpos = sorted(sorted_global_ins_rpos_set)
-                    for i in list_rpos:
-                        del_ins_pos_idx+=1
-                        if i > popped: break
-                    del list_rpos[:del_ins_pos_idx]
-                    sorted_global_ins_rpos_set = set(list_rpos)
-                    
-
-
-            # if the read is beyond the last locus in the bed file the loop stops
-            if read_start > end_coord:
-                while len(global_loci_ends) > 0:
-                    genotyped_loci_count += locus_processor(global_loci_keys, global_loci_ends, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, ref, Chrom, global_loci_info, out, snpQ, snpC, snpD, snpR, phasingR, tbx, flank, sorted_global_ins_rpos_set, log_bool, logger, male)
-                # process the loci left in global_loci_variation
-                break
-
-            # information locally saved for each read and all the loci it covers
-            read_loci_variations = {}
-            # set of homopolymer positions within the reference part that is covered by the read
-            homopoly_positions = {}
-
-            # repeat loci covered by the read
-            loci_coords = []; loci_keys = []
-            left_flank_list = []; right_flank_list = []
-
-            for row in tbx.fetch(read_chrom, read_start, read_end):
-                
-                # adjust read start and end based on soft and hard clippings
-                # soft and hard clippings do not consume the reference bases
-
-                row = row.split('\t')
-                locus_start = int(row[1]);  locus_end = int(row[2]); locus_len = locus_end-locus_start
-
-
-                if (locus_start>=Start[0]) and (locus_end<=End[1]):
-                    if locus_start==Start[0]:
-                        if locus_end==Start[1]: pass
-                        else: continue
-                    pass
-                elif locus_start<Start[0]:
+            hidden = _hidden_path(out_file)
+            self.outfile = f'{hidden}_thread_{thread_idx}.vcf'
+            self.logfile = f'{hidden}_debug_{thread_idx}.log'
+
+        with PysamWarningCapture(self.logfile):
+            self.tbx = pysam.Tabixfile(args.regions)
+            self.bam = pysam.AlignmentFile(bam_file, args.aln_format)
+            self.ref = pysam.FastaFile(args.fasta)
+
+        self.args       = args
+        self.sample_idx = sample_idx
+        self.thread_idx = thread_idx
+        self.karyotype  = args.karyotype[sample_idx]
+        self.chrom      = None
+        self.haploid    = False
+        self.somatic    = False
+        self.logger     = None
+
+        self.outhandle = open(self.outfile, 'w')
+
+        if is_primary:
+            vcf_writer(self.outhandle, self.bam,
+                       Path(bam_file).stem)
+
+        # --- logging ---
+        if args.debug_mode:
+            Path(self.logfile).touch()
+            Path(self.logfile).write_text('') # clear log file if it already exists
+            logging.basicConfig(
+                filename = self.logfile,
+                level    = logging.DEBUG,
+                format   = '%(levelname)s - %(message)s'
+            )
+            self.logger = logging.getLogger('ATaRVa_logger')
+
+        self.disable_progress = False
+
+        # --- count loci per region ---
+        self.cooper_nloci  = 0
+        self.range_nloci   = []
+
+        for region_range in region_ranges:
+            chrom, first_coords, last_coords = region_range
+            count = 0
+            for row in self.tbx.fetch(chrom, first_coords[0], last_coords[1]):
+                fields     = row.split('\t')
+                row_start  = int(fields[1])
+                if count == 0 and row_start != first_coords[0]:
                     continue
-                elif locus_start>=End[0]: break
-                
-
-                # if only the read completely covers the repeat
-                if ( locus_start >= read_start ) & ( locus_end <= read_end ):
-                    left_flank = flank; right_flank = flank
-                    if (locus_start - flank) < read_start:
-                        left_flank = locus_start - read_start
-                    if (locus_end + flank) > read_end:
-                        right_flank  = read_end - locus_end
-                    left_flank_list.append(left_flank)
-                    right_flank_list.append(right_flank)
-
-                    loci_coords.append((locus_start - left_flank, locus_end + right_flank))
-
-                    locus_key = f'{read_chrom}:{locus_start}-{locus_end}'
-                    loci_keys.append(locus_key)
-                    read_loci_variations[locus_key] = {'halen': locus_len, 'alen': locus_len, 'rlen': locus_len, 'seq': []}
-
-                    if locus_key not in global_loci_variations:
-                        global_loci_variations[locus_key] = {'rlen': locus_len, 'reads': [], 'read_allele': {}, 'read_sequence': {}}
-                        global_loci_info[locus_key] = row
-
-                        # adding the locus key when it is first encountered
-                        global_loci_ends.append(locus_end)
-                        global_loci_keys.append(locus_key)
-
-            # if no repeats are covered by the read
-            if len(loci_coords) == 0: continue
-
-            # right_flank_list, left_flank_list = flank_adjustment(loci_coords, exact_loci_coords, right_flank_list, left_flank_list, tracker_idx)
-            # for idx,locus in enumerate(passed_loci_coords):
-            #     loci_coords[idx] = (locus[0]-left_flank_list[idx], locus[1]+right_flank_list[idx]) 
-
-            read_index += 1
-            read_quality = read.query_qualities
-            cigar_tuples = read.cigartuples
-            read_sequence = read.query_sequence
-
-            cigar_one = cigar_tuples[0]
-
-            global_read_ends.append(read_end)
-            global_read_indices.append(read_index)
-            global_read_variations[read_index] = {'s': read_start, 'e': read_end, 'snps': set(), 'dels': set()}
-
-            # for each_coords in loci_coords:
-            #     update_homopolymer_coords(ref.fetch(Chrom, each_coords[0]-100, each_coords[1]+100), each_coords[0]-100, homopoly_positions)
-
-            if read.has_tag('cs'):
-                cs_tag = read.get_tag('cs')
-                parse_cstag(read_index, cs_tag, read_start, loci_keys, loci_coords, read_loci_variations, homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read_quality, cigar_one, sorted_global_snp_list, left_flank_list, right_flank_list, male)
-            else :
-                parse_cigar_tag(read_index, cigar_tuples, read_start, loci_keys, loci_coords, read_loci_variations,
-                                homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read, ref, read_quality, sorted_global_snp_list, left_flank_list, right_flank_list, male)
-
-            for locus_key in read_loci_variations:
-                global_loci_variations[locus_key]['reads'].append(read_index)
-                global_loci_variations[locus_key]['read_allele'][read_index] = [read_loci_variations[locus_key]['halen'], read_loci_variations[locus_key]['alen']]
-                global_loci_variations[locus_key]['read_sequence'][read_index] = read_loci_variations[locus_key]['seq']
-
-        while len(global_loci_ends) > 0:
-            genotyped_loci_count += locus_processor(global_loci_keys, global_loci_ends, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, ref, Chrom, global_loci_info, out, snpQ, snpC, snpD, snpR, phasingR, tbx, flank, sorted_global_ins_rpos_set, log_bool, logger, male)
-                
-        print(f'\nTotal genotyped loci = {genotyped_loci_count} out of {total_loci} in {Chrom} {Start[0]}-{End[1]}\n', file=sys.stderr)
-
-    bam.close()
-    ref.close()
-    tbx.close()
-    out.close()
-
-
-def mini_cooper(bam_file, tbx_file, ref_file, aln_format, contigs, mapq_threshold, outfile, seq_tech, snpQ, snpC, snpD, maxR, minR, snpR, phasingR, tidx, flank, log_bool, karyotype):
-    # this function iterates through each contig and processes the genotypes for each locus
-    tbx  = pysam.Tabixfile(tbx_file)
-    tbx2  = pysam.Tabixfile(tbx_file)
-    bam  = pysam.AlignmentFile(bam_file, aln_format)
-    ref  = pysam.FastaFile(ref_file)
-
-
-    logger = 0
-    if tidx!=-1:
-        if tidx==0:
-            out = open(f'{outfile}.vcf', 'w')
-            vcf_writer(out, bam, bam_file.split("/")[-1].split('.')[0])
-            log_name = f'{outfile}_debug.log'
-        else:
-            out = open(f'{outfile}_thread_{tidx}.vcf', 'w')
-            log_name = f'{outfile}_debug_{tidx}.log'
-
-    else:
-        out = open(f'{outfile}.vcf', 'w')
-        vcf_writer(out, bam, bam_file.split("/")[-1].split('.')[0])
-        log_name = f'{outfile}_debug.log'
-
-    if log_bool:
-        logging.basicConfig(
-            filename=log_name,
-            level=logging.DEBUG,
-            format='%(levelname)s - %(message)s'
+                count += 1
+                if int(fields[1]) == last_coords[0]:
+                    break
+            self.range_nloci.append(count)
+            self.cooper_nloci += count
+
+        # --- progress bar ---
+        self.progress_bar = tqdm(
+            total        = self.cooper_nloci,
+            disable      = self.disable_progress,
+            position     = 1 + 2*thread_idx + 1,
+            desc         = 'Processing ' if args.threads == 1 else f'Processing thread {thread_idx + 1}',
+            file         = self.terminal_stderr, 
+            ascii        = '_>',
+            ncols        = 80,
+            bar_format   = '{l_bar}{bar}{n_fmt}/{total_fmt}',
+            leave        = False,
+            mininterval  = 1      # refresh rate that helps reduce overhead and doesn't cause stray progress bars in multi-thread mode
         )
-        logger = logging.getLogger("MyLogger")
-
-    for contig in contigs:
-
-        Chrom, Start, End = contig
-        male = False
-        if (Chrom in {'chrX', 'chrY', 'X', 'Y'}) and karyotype: male = True
-
-        # print(f"\nProcessing contig {contig}..\n", file=sys.stderr)
-        total_loci = 0
-        genotyped_loci_count = 0
-        for row in tbx.fetch(Chrom, Start[0], End[1]):
-            row = row.split('\t')
-            if (total_loci == 0) and (int(row[2]) != Start[1]): continue
-            total_loci += 1
-            if End[0] == int(row[1]): break
-        print(f"> {Chrom} {Start} {End} Total loci =  {total_loci}", file=sys.stderr)
-
-        homozygous = False
-        ambiguous = False
-
-        global_snp_positions = dict()       # tracking the encountered SNPs
-        global_read_variations = {}         # tracking the variations on each read
-        global_loci_variations = {}         # tracking the variation for each locus
-        global_loci_info = {}               # saving the information of each loci
-
-        # tracking the loci
-        global_loci_ends = []; global_loci_keys    = []        
-        global_read_ends = []; global_read_indices = []
-
-        prev_reads = set()
-        sorted_global_snp_list = []
-        sorted_global_ins_rpos_set = set()
-
-        read_index = 0
-        
-        for row in tbx.fetch(Chrom, Start[0], End[1]):
-
-            row = row.split('\t')
-            locus_start = int(row[1]);  locus_end = int(row[2]); locus_len = locus_end-locus_start
-
-
-            if (locus_start>=Start[0]) and (locus_end<=End[1]):
-                if locus_start==Start[0]:
-                    if locus_end==Start[1]: pass
-                    else: continue
-                pass
-            elif locus_start<Start[0]:
-                continue
-            elif locus_start>=End[0]: break
-            
-           
-            for read in bam.fetch(Chrom, int(row[1]), int(row[2])):
-                if read.mapping_quality < mapq_threshold:
+
+        # --- run genotyping ---
+        for cidx, region_range in enumerate(region_ranges):
+            chrom = region_range[0]
+            bam_stem = Path(bam_file).stem
+            self._reinitialise()
+            self.cooper_readmode(region_range, cidx)
+
+        self.bam.close()
+        self.ref.close()
+        self.tbx.close()
+        self.outhandle.close()
+
+    # --- state management ---
+
+    def _reinitialise(self):
+        """Reset per-region tracking state."""
+        self.cooper_snp_data         = {}
+        self.cooper_read_data        = {}
+        self.cooper_loci_data        = {}
+        self.cooper_loci_info        = {}
+        self.cooper_loci_ends        = deque()
+        self.cooper_loci_keys        = deque()
+        self.cooper_read_ends        = deque()
+        self.cooper_read_indices     = deque()
+        self.prev_reads              = set()
+        self.cooper_sorted_snps      = SortedList()
+        self.cooper_insert_positions = set()
+
+    # --- read processing ---
+
+    def cooper_readmode(self, region_range: tuple, cidx: int):
+        """
+        Genotype a range of loci by streaming through reads.
+
+        :param region_range: (chrom, (start1,end1), (start2,end2))
+        :param cidx:         index of this region in region_ranges
+        """
+        chrom, first_coords, last_coords = region_range
+        self.chrom   = chrom
+        self.haploid = chrom in {'chrX', 'chrY', 'X', 'Y'} and self.karyotype
+
+        region_start = first_coords[0]
+        region_end   = last_coords[1]
+
+        genotyped_count = 0
+        read_index      = 0
+
+        with PysamWarningCapture(self.logfile):
+            for raw_read in self.bam.fetch(chrom, region_start, region_end):
+
+                if raw_read.mapping_quality < self.args.map_qual:
                     continue
 
-                read_chrom = read.reference_name
-                read_start = read.reference_start
-                read_end   = read.reference_end
-                
-                # if only the read completely covers the repeat
-                if not (( locus_start >= read_start ) & ( locus_end <= read_end )):
+                read = ExtendedRead.from_read(raw_read)
+
+                # --- flush completed loci ---
+                while self.cooper_loci_ends and read.ref_start > self.cooper_loci_ends[0]:
+                    genotyped_count  += self.locus_processor()
+                    self.progress_bar.update(1)
+
+                # --- evict expired reads ---
+                while self.cooper_read_ends and read.ref_start > self.cooper_read_ends[0]:
+                    if (self.cooper_loci_ends and self.cooper_read_ends[0] > self.cooper_loci_ends[0]):
+                        break
+
+                    read_end = self.cooper_read_ends.popleft()
+                    rindex   = self.cooper_read_indices.popleft()
+
+                    if rindex in self.cooper_read_data:
+                        for pos in self.cooper_read_data[rindex].snps:
+                            if pos in self.cooper_snp_data:
+                                self.cooper_snp_data[pos].cov -= 1
+                                if self.cooper_snp_data[pos].cov == 0:
+                                    del self.cooper_snp_data[pos]
+                                    self.cooper_sorted_snps.remove(pos)
+                        del self.cooper_read_data[rindex]
+                        self.prev_reads.discard(rindex)
+
+                    # evict expired insert positions
+                    self.cooper_insert_positions = {
+                        p for p in self.cooper_insert_positions if p > read_end
+                    }
+
+                # --- region end reached ---
+                if read.ref_start > region_end:
+                    while self.cooper_loci_ends:
+                        genotyped_count  += self.locus_processor()
+                        self.progress_bar.update(1)
+                    break
+
+                # start_softclip = end_softclip = 0
+                # if read.cigartuples[0][0] == 4 and read.cigartuples[0][1] >= 50: start_softclip = read.cigartuples[0][1]
+                # if read.cigartuples[-1][0] == 4 and read.cigartuples[-1][1] >= 50: end_softclip = read.cigartuples[-1][1]
+                # fetch_start = max(0, read.ref_start - start_softclip)
+                # fetch_end   = min(read.ref_end + end_softclip, last_coords[1])
+                fetch_start = max(0, read.ref_start)
+                fetch_end   = min(read.ref_end, last_coords[1])
+                # --- assign loci to read ---
+                processed_left_softclip = processed_right_softclip = False
+                for row in self.tbx.fetch(chrom, fetch_start, fetch_end):
+                    fields      = row.split('\t')
+                    locus_start = int(fields[1])
+                    locus_end   = int(fields[2])
+                    locus_len   = locus_end - locus_start
+
+                    locus_name  = fields[5] if len(fields) > 5 else None
+
+                    read.loci.append((locus_start, locus_end))
+
+                    # region boundary checks
+                    if locus_start < first_coords[0]:
+                        continue
+                    if locus_start >= last_coords[1]:
+                        break
+                    if not (first_coords[0] <= locus_start and locus_end <= last_coords[1]):
+                        continue
+
+                    # if locus_start < read.ref_start and locus_start - 50 > read.ref_start - start_softclip and not processed_left_softclip:
+                    #     processed_left_softclip = process_softclips(self, read, (locus_start, locus_end), dir='left')
+                    #     start_softclip = read.cigartuples[0][1] if processed_left_softclip else start_softclip
+                    # elif locus_end > read.ref_end and locus_end + 50 < read.ref_end + end_softclip:
+                    #     processed_right_softclip = process_softclips(self, read, (locus_start, locus_end), dir='right')
+                    #     end_softclip = read.cigartuples[-1][1] if processed_right_softclip else end_softclip
+
+                    # read must fully span the locus
+                    if not (read.ref_start <= locus_start and locus_end <= read.ref_end):
+                        continue
+
+                    left_flank  = min(self.args.flank, locus_start - read.ref_start)
+                    right_flank = min(self.args.flank, read.ref_end  - locus_end)
+
+                    read.left_flanks.append(left_flank)
+                    read.right_flanks.append(right_flank)
+                    read.loci_coords.append((locus_start - left_flank,
+                                            locus_end   + right_flank))
+
+                    locus_key = f'{chrom}:{locus_start}-{locus_end}'
+                    read.loci_keys.append(locus_key)
+                    read.loci_data[locus_key] = ReadLocusInfo(halen=0, alen=0, rlen=locus_len, seq=[])
+
+
+                    if locus_key not in self.cooper_loci_data:
+                        self.cooper_loci_data[locus_key] = LocusVariation()
+                        self.cooper_loci_info[locus_key] = LocusInfo(chrom=chrom, start=locus_start, end=locus_end,
+                                                                     motif=fields[3], name=locus_name)
+                        self.cooper_loci_ends.append(locus_end)
+                        self.cooper_loci_keys.append(locus_key)
+
+                if not read.loci_coords:
                     continue
 
-                
-                # information locally saved for each read and all the loci it covers
-                read_loci_variations = {}
-                # set of homopolymer positions within the reference part that is covered by the read
-                homopoly_positions = {}
-    
-                # repeat loci covered by the read
-                loci_coords = []; loci_keys = []
- 
-                left_flank_list = []; right_flank_list = []
-
-                left_flank = flank; right_flank = flank
-                if (locus_start - flank) < read_start:
-                    left_flank = locus_start - read_start
-                if (locus_end + flank) > read_end:
-                    right_flank  = read_end - locus_end
-                left_flank_list.append(left_flank)
-                right_flank_list.append(right_flank)
-
-                loci_coords.append((locus_start - left_flank, locus_end + right_flank))
-
-                locus_key = f'{read_chrom}:{locus_start}-{locus_end}'
-                loci_keys.append(locus_key)
-                read_loci_variations[locus_key] = {'halen': locus_len, 'alen': locus_len, 'rlen': locus_len, 'seq': []}
-
-                if locus_key not in global_loci_variations:
-                    global_loci_variations[locus_key] = {'rlen': locus_len, 'reads': [], 'read_allele': {}, 'read_sequence': {}}
-                    global_loci_info[locus_key] = row
-                    global_loci_ends.append(locus_end)
-                    global_loci_keys.append(locus_key)
-
-        
-                read_index += 1
-                read_quality = read.query_qualities
-                cigar_tuples = read.cigartuples
-                read_sequence = read.query_sequence
-
-                cigar_one = cigar_tuples[0]
-
-                global_read_ends.append(read_end)
-                global_read_indices.append(read_index)
-                global_read_variations[read_index] = {'s': read_start, 'e': read_end, 'snps': set(), 'dels': set()}
-    
-                # for each_coords in loci_coords:
-                #     update_homopolymer_coords(ref.fetch(Chrom, each_coords[0]-100, each_coords[1]+100), each_coords[0]-100, homopoly_positions)
-    
+                read_required = True
+                for key in read.loci_keys:
+                    if self.cooper_loci_data[key].depth >= self.args.max_reads and self.cooper_loci_data[key].min_read_qual >= read.mean_qual:
+                        read_required = False
+                    else:
+                        read_required = True
+                        break
+                # if all loci have enough supporting reads with highest quality; this read is not processed
+                if not read_required: continue
+
+
+                # --- EQX normalisation ---
+                read_sequence = read.sequence
+                for op, length in read.cigartuples:
+                    if op in (0, 7):
+                        break
+                    if op in (1, 4, 8):
+                        pass
+
+                if '=' in read_sequence:
+                    read_sequence = clean_eqsign_readseq(read.chrom, read.ref_start, read.cigartuples,
+                                                         read_sequence, self.ref)
+
+                # --- register read ---
+                read_index   += 1
+                read.index    = read_index
+
+                self.cooper_read_ends.append(read.ref_end)
+                self.cooper_read_indices.append(read.index)
+                self.cooper_read_data[read.index] = ReadInfo(
+                    start       = read.ref_start,
+                    end         = read.ref_end,
+                    snps        = set(),
+                    dels        = [],
+                    methylation = [],
+                    mean_qual   = read.mean_qual,
+                    left_flank  = read.left_flanks,
+                    right_flank = read.right_flanks
+                )
+
+                # --- haplotag extraction ---
+                read.haplotag = [False, None]
+                if self.args.haplotag and read.has_tag(self.args.haplotag):
+                    read.haplotag = [True, read.get_tag(self.args.haplotag)]
+
+                # --- methylation extraction ---
+                mod_bases = (list(read.modified_bases.items()) if read.modified_bases else [])
+
                 if read.has_tag('cs'):
-                    cs_tag = read.get_tag('cs')
-                    parse_cstag(read_index, cs_tag, read_start, loci_keys, loci_coords, read_loci_variations, homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read_quality, cigar_one, sorted_global_snp_list, left_flank_list, right_flank_list, male)
-                else :
-                    parse_cigar_tag(read_index, cigar_tuples, read_start, loci_keys, loci_coords, read_loci_variations,
-                                homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read, ref, read_quality, sorted_global_snp_list, left_flank_list, right_flank_list, male)
-    
-                for locus_key in read_loci_variations:
-                    global_loci_variations[locus_key]['reads'].append(read_index)
-                    global_loci_variations[locus_key]['read_allele'][read_index] = [read_loci_variations[locus_key]['halen'], read_loci_variations[locus_key]['alen']]
-                    global_loci_variations[locus_key]['read_sequence'][read_index] = read_loci_variations[locus_key]['seq']
-            
-            while len(global_loci_ends) > 0:
-
-                genotyped_loci_count += locus_processor(global_loci_keys, global_loci_ends, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, ref, Chrom, global_loci_info, out, snpQ, snpC, snpD, snpR, phasingR, tbx2, flank, sorted_global_ins_rpos_set, log_bool, logger, male)
-
-            while len(global_read_ends) > 0:
-
-                popped = global_read_ends.pop(0)
-                rindex = global_read_indices.pop(0)
-                if rindex in global_read_variations:
-                    for pos in global_read_variations[rindex]['snps']:
-                        if pos in global_snp_positions:
-                            global_snp_positions[pos]['cov'] -= 1
-                    del_snps = []
-                    for pos in global_snp_positions: 
-                        if global_snp_positions[pos]['cov'] == 0:
-                            del_snps.append(pos)
-                            sorted_global_snp_list.remove(pos)
-                    for snp in del_snps:
-                        del global_snp_positions[snp]
-                    del global_read_variations[rindex]
-                    del del_snps
-
-                    if rindex in prev_reads: prev_reads.remove(rindex)
-                del_ins_pos_idx = 0
-                list_rpos = sorted(sorted_global_ins_rpos_set)
-                for i in list_rpos:
-                    del_ins_pos_idx+=1
-                    if i > popped: break
-                del list_rpos[:del_ins_pos_idx]
-                sorted_global_ins_rpos_set = set(list_rpos)
-
-        print(f'\nTotal genotyped loci = {genotyped_loci_count} out of {total_loci} in {Chrom} {Start[0]}-{End[1]}\n', file=sys.stderr)
-
-    bam.close()
-    ref.close()
-    tbx.close()
-    tbx2.close()
-    out.close()
\ No newline at end of file
+                    parse_cstag(self, read)
+                else:
+                    parse_cigar(self, read)
+
+                for mods in mod_bases:
+                    if mods[0][0] == 'C' and mods[0][2] == 'm':
+                        mm_tag_extract(read, mods[1])
+                        self.cooper_read_data[read_index].methylation = read.methylation_calls
+                        break
+
+                # --- populate loci data ---
+                for locus_key, locus_read_info in read.loci_data.items():
+                    if not locus_read_info.seq: continue
+                    ldata = self.cooper_loci_data[locus_key]
+                    if ldata.depth >= self.args.max_reads:
+                        if read.mean_qual > ldata.min_read_qual:
+                            ldata.reads.append(read.index)
+                            ldata.depth += 1
+                            ldata.read_alens[read.index]     = [locus_read_info.halen, locus_read_info.alen]
+                            ldata.read_aseqs[read.index]     = locus_read_info.seq
+                            ldata.read_haplotags[read.index] = read.haplotag[1]
+                            # remove lowest quality read
+                            if ldata.min_qual_read in ldata.reads:
+                                ldata.reads.remove(ldata.min_qual_read)
+                                del ldata.read_alens[ldata.min_qual_read]
+                                del ldata.read_aseqs[ldata.min_qual_read]
+                                del ldata.read_haplotags[ldata.min_qual_read]
+                                ldata.depth -= 1
+                            # update minimum quality read
+                            ldata.min_read_qual = float('inf')
+                            for r in ldata.reads:
+                                if ldata.min_read_qual > self.cooper_read_data[r].mean_qual:
+                                    ldata.min_read_qual = self.cooper_read_data[r].mean_qual
+                                    ldata.min_qual_read = r
+                            
+                    else:
+                        ldata.reads.append(read.index)
+                        ldata.depth += 1
+                        ldata.read_alens[read.index]     = [locus_read_info.halen, locus_read_info.alen]
+                        ldata.read_aseqs[read.index]     = locus_read_info.seq
+                        ldata.read_haplotags[read.index] = read.haplotag[1]
+                        if ldata.min_read_qual > read.mean_qual:
+                            ldata.min_read_qual = read.mean_qual
+                            ldata.min_qual_read = read.index
+
+        # --- flush remaining loci ---
+        while self.cooper_loci_ends:
+            genotyped_count  += self.locus_processor()
+            self.progress_bar.update(1)
+
+
+    def locus_processor(self):
+        """
+        Genotype the next queued locus using collected read data.
+
+        :return: 1 if locus was successfully genotyped, 0 otherwise
+        """
+        self.cooper_loci_ends.popleft()
+        locus_key   = self.cooper_loci_keys.popleft()
+        locus_data  = self.cooper_loci_data[locus_key]
+        locus       = self.cooper_loci_info[locus_key]
+
+        if locus_key not in self.cooper_loci_data:
+            write_fail_call(self, locus_key)
+            return 0
+
+        # --- fetch neighbouring loci ---
+        locus_data.neighbors = [
+            (int(r.split('\t')[1]), int(r.split('\t')[2]))
+            for r in self.tbx.fetch(self.chrom, locus.start - self.args.flank, locus.end + self.args.flank)
+        ]
+
+        # --- ensure sorted SNPs are populated ---
+        if not self.cooper_sorted_snps:
+            for pos in self.cooper_snp_data:
+                self.cooper_sorted_snps.add(pos)
+
+        # --- process locus ---
+        process_locus(self, locus_key)
+
+        locus_data    = self.cooper_loci_data[locus_key]
+        read_seqs     = locus_data.read_aseqs
+        # --- category 1 — homozygous ---
+        if locus_data.hap_category == 1:
+            read_seqs = [read_seqs[rid][0] for rid in locus_data.reads if read_seqs[rid][0] != '']
+            seq_counter = {}
+            for seq in read_seqs:
+                try: seq_counter[seq] += 1
+                except KeyError: seq_counter[seq] = 1
+            max_allele = max(seq_counter, key=seq_counter.get) if seq_counter else None
+
+            if len(read_seqs) == 0:
+                # homozygous deletion genotype
+                ALT = '<DEL>'
+                locus_data.gt_alens  = (0, 0)
+                locus_data.gt_arange = '0-0,0-0'
+                locus_data.gt_aseqs  = (ALT, ALT)
+
+            elif max_allele == self.ref.fetch(locus.chrom, locus.start, locus.end):
+                # homozygous reference genotype
+                ALT = '.'
+                locus_data.gt_alens  = (locus.length, locus.length)
+                locus_data.gt_arange = f'{locus.length}-{locus.length},{locus.length}-{locus.length}'
+                locus_data.gt_aseqs  = (max_allele, max_allele)
+                ref_allele = self.ref.fetch(locus.chrom, locus.start, locus.end)
+                meth_data = calculate_methylation(locus_data.reads, locus_data.read_methylation, ref_allele)
+                locus_data.hap_meth_data = (meth_data, meth_data)
+
+            else:
+                ALT = max_allele
+                locus_data.gt_alens      = (len(ALT), len(ALT))
+                locus_data.gt_arange     = f'{len(ALT)}-{len(ALT)}'
+                locus_data.gt_aseqs      = (ALT, ALT)
+                meth_data = calculate_methylation(locus_data.reads, locus_data.read_methylation, ALT)
+                locus_data.hap_meth_data = (meth_data, meth_data)
+
+            write_homozygous_call(self, locus_key)
+            locus_data.is_genotyped = 1
+
+        # --- category 2 — ambiguous ---
+        elif locus_data.hap_category == 2:
+            analyse_genotype(self, locus_key)
+            if not locus_data.is_genotyped:
+                msg = SKIP_MESSAGES.get(
+                    locus_data.skip_code,
+                    "Locus skipped — insufficient significant SNPs.")
+
+        # --- category 3 — phased / heterozygous ---
+        elif locus_data.hap_category == 3:
+            genotypes    = []
+            allele_count = {}
+            ALT_seqs     = []
+            phased_reads = []
+            alen_lists   = []
+
+            for hap_reads in locus_data.hap_read_sets:
+                phased_reads.append(len(hap_reads))
+                seqs      = [read_seqs[rid][0] for rid in hap_reads
+                             if read_seqs[rid][0]]
+                alen_list = [len(read_seqs[rid][0]) for rid in hap_reads]
+                alen_lists.append(alen_list)
+
+                if seqs:
+                    ALT           = consensus_seq_poa(seqs)
+                    allele_length = len(ALT)
+                else:
+                    ALT           = '<DEL>'
+                    allele_length = 0
+
+                ALT_seqs.append(ALT)
+                genotypes.append(allele_length)
+                key = allele_length if allele_length not in allele_count \
+                      else str(allele_length)
+                allele_count[key] = len(hap_reads)
+
+            (l1, u1) = np.percentile(alen_lists[0], [2.5, 97.5])
+            (l2, u2) = np.percentile(alen_lists[1], [2.5, 97.5])
+            allele_range = f'{l1}-{u1},{l2}-{u2}'
+
+            write_heterozygous_call(self, locus_key)
+            locus_data.is_genotyped = 1
+
+        # --- no category — write fail if needed ---
+        else:
+            if locus_data.skip_code == 0:
+                write_fail_call(self, locus_key)
+
+        # --- cleanup ---
+        del self.cooper_loci_data[locus_key]
+        del self.cooper_loci_info[locus_key]
+
+        return locus_data.is_genotyped
diff --git a/ATARVA/cigar_utils.py b/ATARVA/cigar_utils.py
index 4dce54d..0636375 100644
--- a/ATARVA/cigar_utils.py
+++ b/ATARVA/cigar_utils.py
@@ -1,141 +1,196 @@
 import bisect
-import sys
 import numpy as np
+
 from ATARVA.operation_utils import match_jump, deletion_jump, insertion_jump
 from ATARVA.md_utils import parse_mdtag
+from ATARVA.structures import SNP
+
+def subex(ref, query):
+    """
+    compare reference and query sequence and get mismatch positions
 
-def subex(ref, que):
+    :param ref: reference sequence
+    :param query: query sequence
+    :return: list of mismatch positions
+    """
 
-    if '=' in que:
-        array = np.frombuffer(que.encode(), dtype=np.byte)
+    if '=' in query:
+        array = np.frombuffer(query.encode(), dtype=np.byte)
         substitution_indices = np.where(array != ord('='))[0]
         
     else:
         array1 = np.frombuffer(ref.encode(), dtype=np.byte)
-        array2 = np.frombuffer(que.encode(), dtype=np.byte)
+        array2 = np.frombuffer(query.encode(), dtype=np.byte)
         substitution_indices = np.where(array1 != array2)[0]
         
-    return substitution_indices.tolist()
+    return substitution_indices
+
+
+def outside_locus(loci_coords, rpos):
+    """
+    Check if the position is outside all locus ranges (sorted coords)
+
+    :param loci_coords: list of locus coordinates
+    :param rpos: position to be checked
+    :return: True if the position is outside all locus ranges, False otherwise
+    """
+
+    starts = [c[0] for c in loci_coords]
+    idx    = bisect.bisect_right(starts, rpos) - 1
+    return idx < 0 or rpos > loci_coords[idx][1]
+
+
+def parse_cigar(cooper, read):
+    """
+    parse the cigar to identify loci specific variations and the SNPs
 
-def parse_cigar_tag(read_index, cigar_tuples, read_start, loci_keys, loci_coords, read_loci_variations,
-                homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read, ref, read_quality, sorted_global_snp_list, left_flank_list, right_flank_list, male):
-    
-    rpos = read_start   # NOTE: The coordinates are 1 based in SAM
-    qpos = 0            # starts from 0 the sub string the read sequence in python
+    :param cooper: ATaRVa object
+    :param read: pysam AlignedSegment object
+    """
 
-    chrom = read.reference_name
+    rpos = read.ref_start   # NOTE: The coordinates are 1 based in SAM
+    qpos = 0                # starts from 0 the sub string the read sequence in python
+
+    chrom = read.chrom
     repeat_index = 0
-    tracked = [False] * len(loci_coords)
-
-    locus_qpos_range = []
-    loci_flank_qpos_range = []
-    out_insertion_qpos_ranges_left = []
-    out_insertion_qpos_ranges_right = []
-    left_ins_rpos = []
-    right_ins_rpos = []
-    for _ in loci_coords:
-        locus_qpos_range.append([0,0])
-        loci_flank_qpos_range.append([0,0])
-        out_insertion_qpos_ranges_left.append([])
-        out_insertion_qpos_ranges_right.append([])
-        left_ins_rpos.append([])
-        right_ins_rpos.append([])
-
-    flank_track = [[False,False] for _ in loci_coords]
-
-    X_tag = False
-    insertion_point = {}
-
-    md = 0
-    if read.has_tag('MD'):
-        md = 1
-
-    if sorted_global_snp_list == None:
-        sorted_global_snp_list = []
-
-    for c, cigar in enumerate(cigar_tuples):
-        if cigar[0] == 4:
-           qpos += cigar[1] 
+
+    locus_query_range = np.zeros((len(read.loci_coords), 2), dtype=int)
+    flank_query_range = np.zeros((len(read.loci_coords), 2), dtype=int)
+    left_flank_insertions  = [[] for _ in read.loci_coords] # stores insertions in left flank as (rpos, qstart, qend)
+    right_flank_insertions = [[] for _ in read.loci_coords] # stores insertions in right flank as (rpos, qstart, qend)
+    locus_reached = [False for _ in read.loci_coords]
+    locus_boundary_crossed = [[False,False] for _ in read.loci_coords]
+
+    has_subop = False
+    has_MD = read.has_tag('MD')
+
+    insert_positions = {}
+
+    haploid              = cooper.haploid
+    snp_data             = cooper.cooper_snp_data
+    cooper_prev_reads    = cooper.prev_reads
+    is_haplotag          = cooper.args.haplotag
+    reference            = cooper.ref
+    snp_qual_cutoff      = cooper.args.snp_qual
+    cooper_sorted_snps   = cooper.cooper_sorted_snps
+    cooper_loci_keys     = cooper.cooper_loci_keys
+    cooper_loci_info     = cooper.cooper_loci_info
+    cooper_snp_data      = cooper.cooper_snp_data
+    cooper_read_data     = cooper.cooper_read_data
+    is_haploid           = cooper.haploid
+
+    read_index = read.index
+    qseq       = read.query_sequence
+    qquals     = read.query_qualities
+
+    no_snp_range = 3
+
+    for cigar in read.cigartuples:
+        if cigar[0] == 4: qpos += cigar[1]    # softclip; adjust the qpos but not rpos; also consider the possibility of match after softclip
+ 
         elif cigar[0] == 2:     # deletion
-            deletion_length = cigar[1]
-            if not male:
-                global_read_variations[read_index]['dels'] |= set(range(rpos, rpos+deletion_length))
-            rpos += cigar[1]
-            repeat_index += deletion_jump(deletion_length, rpos, repeat_index, loci_keys, tracked, loci_coords,
-                                          homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            deletion_len = cigar[1]
+            if not haploid:
+                cooper_read_data[read_index].dels.extend([rpos, rpos + deletion_len])
+                cooper_read_data[read_index].no_snps.update(range(rpos-no_snp_range, rpos + deletion_len + 1 + no_snp_range))
+            rpos += deletion_len
+            repeat_index += deletion_jump(read, rpos, qpos, deletion_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed)
+
         elif cigar[0] == 1:     # insertion
-            insertion_point[rpos] = cigar[1]
-            insert = read_sequence[qpos:qpos+cigar[1]]
-            insert_length = cigar[1]
-            qpos += cigar[1]
-            repeat_index += insertion_jump(insert_length, insert, rpos, repeat_index, loci_keys,
-                                           tracked, loci_coords, homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list, out_insertion_qpos_ranges_left, out_insertion_qpos_ranges_right, left_ins_rpos, right_ins_rpos)
-        elif cigar[0] == 0: # match (both equals & difference)
-            if not md:
-                ref_sequence = ref.fetch(chrom, rpos, rpos+cigar[1])
-                query_sequence = read_sequence[qpos:qpos+cigar[1]]
-                sub_pos = []
-                if len(ref_sequence)==len(query_sequence):
-                    sub_pos = subex(ref_sequence, query_sequence)
-                else:
-                    print('Error in fetching in sequences of ref & read for substitution')
-                    sys.exit()
-                for each_sub in sub_pos:
-                    sub_nuc = query_sequence[each_sub]
-                    Q_value = read_quality[qpos+each_sub]
-                    global_read_variations[read_index]['snps'].add(rpos+each_sub)
-                    if rpos+each_sub not in global_snp_positions:
-                        global_snp_positions[rpos+each_sub] = { 'cov': 1, sub_nuc: {read_index}, 'Qval': {read_index:Q_value} }
-                        bisect.insort(sorted_global_snp_list, rpos+each_sub)
+            insert_positions[rpos] = cigar[1]
+            cooper_read_data[read_index].no_snps.update(range(rpos-no_snp_range, rpos + 1 + no_snp_range))
+            insert_len = cigar[1]
+            homopolymer_insert = False
+            if len(set(qseq[qpos:qpos+insert_len])) == 1: homopolymer_insert = True
+
+            qpos += insert_len
+            repeat_index += insertion_jump(read, rpos, qpos, insert_len, homopolymer_insert, repeat_index, locus_query_range, flank_query_range,
+                                           locus_reached, locus_boundary_crossed, left_flank_insertions, right_flank_insertions)
+        
+        elif cigar[0] == 0: # match (includes substitutions)
+            match_len = cigar[1]
+            if not has_MD and (not haploid) and (not is_haplotag):
+                ref_sequence   = reference.fetch(chrom, rpos, rpos + match_len)
+                query_sequence = qseq[qpos:qpos + match_len]
+
+                assert len(ref_sequence) == len(query_sequence), \
+                    "Error: fetching sequences based on CIGAR. Please check cigar formats"
+
+                substitutions = subex(ref_sequence, query_sequence)
+                for sub_pos in substitutions:
+                    if not outside_locus(read.loci_coords, rpos + sub_pos):
+                        continue
+                    sub_nuc  = query_sequence[sub_pos]
+                    sub_qual = qquals[qpos + sub_pos]
+                    if sub_qual < snp_qual_cutoff: continue
+
+                    sub_pos = rpos + sub_pos
+                    cooper_read_data[read_index].snps.add(sub_pos)
+                    if sub_pos not in snp_data:
+                        snp_data[sub_pos] = SNP(cov = 1, sub = { sub_nuc: {read_index} }, qual={ read_index: sub_qual })
+                        cooper_sorted_snps.add(sub_pos)
                     else:
-                        global_snp_positions[rpos+each_sub]['cov'] += 1
-                        global_snp_positions[rpos+each_sub]['Qval'][read_index] = Q_value
-                        if sub_nuc in global_snp_positions[rpos+each_sub]: 
-                            global_snp_positions[rpos+each_sub][sub_nuc].add(read_index)
-                            
-                        else: global_snp_positions[rpos+each_sub][sub_nuc] = {read_index}
+                        snp_data[sub_pos].cov += 1
+                        snp_data[sub_pos].qual[read_index] = sub_qual
+                        if sub_nuc in snp_data[sub_pos].sub:
+                            snp_data[sub_pos].sub[sub_nuc].add(read_index)
+                        else:
+                            snp_data[sub_pos].sub[sub_nuc] = {read_index}
+
+            qpos += match_len; rpos += match_len
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed)
+
+        elif cigar[0] == 7: # exact match (does not include substitutions)
+            has_subop = True
+            match_len = cigar[1]
+            qpos += match_len; rpos += match_len
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed)
 
-            qpos += cigar[1]; rpos += cigar[1]; match_len = cigar[1]
-            repeat_index += match_jump(rpos, repeat_index, loci_coords,tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+        elif cigar[0] == 8: # substitution (difference)
+            has_subop = True
+            match_len = cigar[1]
+            if (not haploid) and outside_locus(read.loci_coords, rpos) and (not is_haplotag):
+                sub_nuc  = qseq[qpos]
+                sub_qual = qquals[qpos]
+                if sub_qual >= snp_qual_cutoff:
+                    cooper_read_data[read_index].snps.add(rpos)
+                    if rpos not in snp_data:
+                        snp_data[rpos] = SNP(cov = 1, sub = { sub_nuc: {read_index} }, qual={ read_index: sub_qual })
+                        cooper_sorted_snps.add(rpos)
+                    else:
+                        snp_data[rpos].cov += 1
+                        snp_data[rpos].qual[read_index] = sub_qual
+                        if sub_nuc in snp_data[rpos].sub: 
+                            snp_data[rpos].sub[sub_nuc].add(read_index)
+                        else:
+                            snp_data[rpos].sub[sub_nuc] = {read_index}
 
-        elif cigar[0] == 7: # exact match (equals)
-            X_tag = True
-            qpos += cigar[1]; rpos += cigar[1]; match_len = cigar[1]
-            repeat_index += match_jump(rpos, repeat_index, loci_coords,tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            qpos += match_len; rpos += match_len
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed)
 
-        elif cigar[0] == 8: # substitution (difference)
-            X_tag = True
-            if not male:
-                sub_nuc = read_sequence[qpos]
-                Q_value = read_quality[qpos]
-                global_read_variations[read_index]['snps'].add(rpos)
-                if rpos not in global_snp_positions:
-                    global_snp_positions[rpos] = { 'cov': 1, sub_nuc: {read_index}, 'Qval': {read_index:Q_value} }
-                    bisect.insort(sorted_global_snp_list, rpos)
-                else:
-                    global_snp_positions[rpos]['cov'] += 1
-                    global_snp_positions[rpos]['Qval'][read_index] = Q_value
-                    if sub_nuc in global_snp_positions[rpos]: 
-                        global_snp_positions[rpos][sub_nuc].add(read_index)
-                        
-                    else: global_snp_positions[rpos][sub_nuc] = {read_index}
-            qpos += cigar[1]; rpos += cigar[1]; match_len = cigar[1]
-            repeat_index += match_jump(rpos, repeat_index, loci_coords,tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
-
-    if not X_tag :
+    if not has_subop :
         if read.has_tag('MD'):
-            if cigar_tuples[0][0] == 4: qpos = cigar_tuples[0][1]
-            else: qpos=0
-            MD_tag = read.get_tag('MD')
-            parse_mdtag(MD_tag, qpos, read_start, global_read_variations, global_snp_positions, read_index, read_quality, read_sequence, sorted_global_snp_list, insertion_point)
-
-    for idx,each_key in enumerate(loci_keys):
-        s_pos = locus_qpos_range[idx][0]
-        e_pos = locus_qpos_range[idx][1]
-        loci_flank_qpos_range[idx][0] = loci_flank_qpos_range[idx][0] - s_pos
-        loci_flank_qpos_range[idx][1] = loci_flank_qpos_range[idx][1] - s_pos
-        ins_left = [(each_tuple[0]-s_pos, each_tuple[1]-s_pos) for each_tuple in out_insertion_qpos_ranges_left[idx]]
-        ins_right = [(each_tuple[0]-s_pos, each_tuple[1]-s_pos) for each_tuple in out_insertion_qpos_ranges_right[idx]]
-        read_loci_variations[each_key]['seq'] = [read_sequence[s_pos:e_pos], loci_flank_qpos_range[idx], ins_left, ins_right, left_ins_rpos[idx], right_ins_rpos[idx]]
-
-    
\ No newline at end of file
+            if read.cigartuples[0][0] == 4: qpos = read.cigartuples[0][1]
+            else: qpos = 0
+            parse_mdtag(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                        snp_qual_cutoff, is_haploid, is_haplotag, read, qpos, insert_positions)
+
+    num_read_loci = len(read.loci_coords)
+    for idx, locus_key in enumerate(read.loci_keys):
+        # changing all the query coordinates to be relative to the start of the flank start
+        flank_query_start = flank_query_range[idx][0]
+        if idx == 0: read.methyl_start = flank_query_start
+
+        flank_query_end = flank_query_range[idx][1]
+        if idx == num_read_loci - 1: read.methyl_end = flank_query_end
+
+        locus_query_range[idx][0] = locus_query_range[idx][0] - flank_query_start
+        locus_query_range[idx][1] = locus_query_range[idx][1] - flank_query_start
+
+        left_flank_insertions[idx]  = [(coords[0], coords[1] - flank_query_start, coords[2] - flank_query_start) for coords in left_flank_insertions[idx] ]
+        right_flank_insertions[idx] = [(coords[0], coords[1] - flank_query_start, coords[2] - flank_query_start) for coords in right_flank_insertions[idx] ]
+        read.loci_data[locus_key].seq = [qseq[flank_query_start:flank_query_end],
+                                         locus_query_range[idx],
+                                         left_flank_insertions[idx],
+                                         right_flank_insertions[idx],
+                                         flank_query_start, flank_query_end]
diff --git a/ATARVA/consensus.py b/ATARVA/consensus.py
index 4c5aa1e..5f32fd3 100644
--- a/ATARVA/consensus.py
+++ b/ATARVA/consensus.py
@@ -1,11 +1,18 @@
 import pyabpoa as pa
+import statistics as stats
+from collections import Counter
 
-def consensus_seq_poa(seqs, alen):
-    if len(seqs)<7:
+def consensus_seq_poa(seqs):
+    if len(seqs) < 7:
         cons_algrm='MF'
     else:
         cons_algrm='HB'
 
+    median_len = len(stats.median_high(seqs))
+    if median_len > 10000:
+        fseqs = [seq for seq in seqs if len(seq) == median_len]
+        return ''.join(Counter(bases).most_common(1)[0][0] for bases in zip(*fseqs))
+
     abpoa = pa.msa_aligner(cons_algrm=cons_algrm)
     result = abpoa.msa(seqs, out_cons=True, out_msa=False)
     return result.cons_seq[0]
\ No newline at end of file
diff --git a/ATARVA/core.py b/ATARVA/core.py
index f837f27..61b8ce9 100644
--- a/ATARVA/core.py
+++ b/ATARVA/core.py
@@ -2,291 +2,54 @@
 
 """
     ATaRVa (pronunced as atharva) is a tool designed to analyse tandem repeat variation
-    from long/short read whole genome sequencing data.
+    from genome sequencing data. Besides genotyping the locus ATaRVa provides functionality
+    to decompose motifs, analyse base modifications along with interactive visualizations.
 """
 
-import sys, os
-import pysam
-import timeit as ti
+import sys
 import argparse as ap
-from multiprocessing import Process
 
+from ATARVA.genotype import genotype_parser
+from ATARVA.merge import merge_parser
 from ATARVA.version import __version__
-from ATARVA.baseline import *
 
-def parse_args():
-    parser = ap.ArgumentParser()
-    parser._action_groups.pop()
-
-    print("ATaRVa (atharva) - Analysis of Tandem Repeat Variants\nSowpati Lab\n")
-
-    required = parser.add_argument_group('Required arguments')
-    required.add_argument('-fi',  '--fasta',   required=True, metavar='<FILE>', help='input reference fasta file')
-    required.add_argument('--bams', nargs='+', required=True, metavar='<FILE>', help='samples alignment files. allowed formats: SAM, BAM, CRAM')
-    required.add_argument('-bed', '--regions', required=True, metavar='<FILE>', help='input regions file. the regions file should be strictly in bgzipped tabix format. \
-                                                                  If the regions input file is in bed format. First sort it using bedtools. Compress it using bgzip. \
-                                                                  Index the bgzipped file with tabix command from samtools package.')
-
-    optional = parser.add_argument_group('Optional arguments')
-    optional.add_argument('--format', type=str, metavar='<STR>', default='bam', help='format of input alignment file. allowed options: [cram, bam, sam]. default: [bam]')
-    optional.add_argument('-q', '--map-qual', type=int, metavar='<INT>', default=5, help='minimum mapping quality of the reads to be considered. [default: 5]')
-    optional.add_argument('--contigs', nargs='+', help='contigs to get genotyped [chr1 chr12 chr22 ..]. If not mentioned every contigs in the region file will be genotyped.')
-    optional.add_argument('--min-reads', type=int, metavar='<INT>', default=10, help='minimum read coverage after quality cutoff at a locus to be genotyped. [default: 10]')
-    optional.add_argument('--max-reads', type=int, metavar='<INT>', default=300, help='maximum number of reads to be used for genotyping a locus. [default: 100]')
-    optional.add_argument('--snp-dist', type=int, metavar='<INT>', default=5000, help='maximum distance of the SNP from repeat region to be considered for phasing. [default: 5000]')
-    optional.add_argument('--snp-count', type=int, metavar='<INT>', default=3, help='number of SNPs to be considered for phasing (minimum value = 1). [default: 3]')
-    optional.add_argument('--snp-qual', type=int, metavar='<INT>', default=13, help='minimum basecall quality at the SNP position to be considered for phasing. [default: 13]')
-    optional.add_argument('--flank', type=int, metavar='<INT>', default=10, help='length of the flanking region (in base pairs) to search for insertion with a repeat in it. [default: 10]')
-    optional.add_argument('--snp-read', type=float, metavar='<FLOAT>', default=0.2, help='a positive float as the minimum fraction of snp\'s read contribution to be used for phasing. [default: 0.25]')
-    optional.add_argument('--phasing-read', type=float, metavar='<FLOAT>', default=0.4, help='a positive float as the minimum fraction of total read contribution from the phased read clusters. [default: 0.4]')
-    optional.add_argument('-o',  '--vcf', type=str, metavar='<FILE>', default='', help='name of the output file, output is in vcf format. [default: sys.stdout]')
-    optional.add_argument('--platform', type=str, metavar='<STR>', default='simplex', help='sequencing platform used for generating the data. changing this will have an affect \
-                                                                           on phasing which is happening on SNPs. allowed options: [hifi, duplex, simplex-hq, simplex]. \
-                                                                           default: [simplex]')
-    optional.add_argument('--karyotype', nargs='+', help='karyotype of the samples [XY XX]')
-    optional.add_argument('-p',  '--processor', type=int, metavar='<INT>', default=1, help='number of processor. [default: 1]')
-    optional.add_argument('-v', '--version', action='version', version=f'ATaRVa version {__version__}')
-    optional.add_argument('-log', '--debug_mode', action='store_true', help="write the debug messages to log file. [default: False]")
-
-    
-
-    if len(sys.argv) == 1:
-        parser.print_help()
-        sys.exit()
-
-    return parser.parse_args()
-
-
-def f_check(path):
-    try:
-        f = pysam.FastaFile(path)
-        f.close()
-    except (FileNotFoundError, ValueError, OSError) as e:
-        print(f"Error: {path} is not a valid FASTA file. {str(e)}")
-        sys.exit()
-    except Exception as e:
-        print("An unexpected error occurred:", str(e))
-        sys.exit()
-
-def b_check(path, aln_format):
-    try:
-        b = pysam.AlignmentFile(path, aln_format)
-        header = b.header
-        if 'HD' in header and 'SO' in header['HD']:
-            sort_order = header['HD']['SO']
-            if sort_order == 'coordinate':
-                pass
-                # print(f"Alignment file sort order: {sort_order}")
-            else:
-                print(f"Alignment file sort order: {sort_order}. It should be sorted by \'coordinate\'!!")
-                print(f"Use: samtools sort sorted_{path.split('/')[-1]} {path.split('/')[-1]}")
-                sys.exit()
-        else:
-            print("No sort order specified in the header.")
-            print(f"Use: samtools sort sorted_{path.split('/')[-1]} {path.split('/')[-1]}")
-            sys.exit()
-
-        b.close()
-    except (FileNotFoundError, ValueError, OSError) as e:
-        print(f"Error: {path} is not a valid alignment file. {str(e)}")
-        sys.exit()
-    except Exception as e:
-        print("An unexpected error occurred:", str(e))
-        sys.exit()
-
-def t_check(path):
-    try:
-        t = pysam.TabixFile(path)
-        t.close()
-    except (FileNotFoundError, ValueError, OSError) as e:
-        print(f"Error: {path} is not a valid tabix file. {str(e)}")
-        sys.exit()
-    except Exception as e:
-        print("An unexpected error occurred:", str(e))
-        sys.exit()
+contact = """\nFor queries or suggestions, please contact:
+Divya Tej Sowpati - tej at csirccmb dot org
+Abishek Kumar S - abishekks at csirccmb dot org
+Akshay Kumar Avvaru - avvaruakshay at gmail dot com"""
 
 def main():
+    parser = ap.ArgumentParser(prog="atarva",
+                               add_help=False,
+                               formatter_class=ap.RawTextHelpFormatter)
 
-    start_time = ti.default_timer()
-    args = parse_args()
-
-    for arg in vars(args):
-        print (arg, getattr(args, arg))
-    print('\n')
-
-    f_check(args.fasta)
-
-    aln_format = ''         # format of the alignment file
-    if   args.format == 'cram': aln_format = 'rc'
-    elif args.format == 'sam':  aln_format = 'r'
-    else:            aln_format = 'rb'
-
-    for each_bam in args.bams:
-        b_check(each_bam, aln_format)
-    t_check(args.regions)
-    
-
-    seq_platform = args.platform     # seq_tech of the alignment file
-
-
-    out_file = sys.stdout
-    if args.vcf:
-        if '.vcf' == args.vcf[-4:]:
-            out_file = f'{args.vcf}'[:-4]
-        elif args.vcf[-1]=='/':
-            out_file = args.vcf + "atarva_tr"
-        else:
-            out_file = f'{args.vcf}'
-    # else: out_file = f'{".".join(args.bams.split(".")[:-1])}'
-    external_name = out_file
-
-    tbx  = pysam.Tabixfile(args.regions)
-    total_loci = 0
-    if not args.contigs:
-        contigs = sorted(tbx.contigs)
-        for row in tbx.fetch():
-            total_loci += 1
-    else:
-        contigs = sorted(args.contigs)
-        for each_contig in args.contigs:
-            for row in tbx.fetch(each_contig):
-                total_loci += 1
-
-    if not args.karyotype:
-        karyotype_list = [False]*len(args.bams)
-    else:
-        karyotype_list = [i=='XY' for i in args.karyotype]
-
-    threads = args.processor
-    split_point = total_loci // threads
-    if split_point == 0:
-        split_point = 1
-
-    
-    fetcher = []
-    line_count = 0
-    current_split = []
-    for each_contig in contigs:
-        init = 0
-        for row in tbx.fetch(each_contig):
-            line_count += 1
-            if init == 0:
-                Row = row.split('\t')
-                chrom = Row[0]
-                start_coord = (int(Row[1]), int(Row[2]))
-                init=1
-            if len(fetcher) < threads-1:
-                if line_count % split_point == 0:
-                    end_coord = (int(row.split('\t')[1]), int(row.split('\t')[2]))
-                    current_split.append([chrom, start_coord, end_coord])
-                    fetcher.append(tuple(current_split))
-                    line_count = 0
-                    current_split = []
-                    init = 0
-        if init != 0:
-            end_coord = (int(row.split('\t')[1]), int(row.split('\t')[2]))
-            current_split.append([chrom, start_coord, end_coord])
-    fetcher.append(tuple(current_split))
-    tbx.close()
+    parser._action_groups.pop()
 
-    mbso = 0
-    if (len(args.bams)>1) and (args.vcf):
-        mbso = 1
-    
-    for kidx, each_bam in enumerate(args.bams):
-        out_file = external_name
-        print(f"Processing sample {each_bam.split('/')[-1]}\n")
+    print(f"ATaRVa - Analysis of Tandem Repeat Variants\nSowpati Lab\n", file=sys.stderr)
 
-        count = 0
-        aln_file = pysam.AlignmentFile(each_bam, aln_format)
-        length = 0
-        for read in aln_file.fetch():
-            if (read.flag & 0X400) or (read.flag & 0X100): continue 
-            count+=1
-            string = read.cigarstring
-            length += read.query_length
-            if read.has_tag('cs'):
-                print("CS tag detected. Processing using CS tag...\n")
-                break
-            elif (string!=None) and (('X' in string) or ('=' in string)):
-                print("CIGAR(X/=) tag detected. Processing using CIGAR(X/=) tag...\n")
-                break
-            elif read.has_tag('MD'):
-                print("MD tag detected. Processing using MD tag...")
-                print("Include CS tag or CIGAR tag with 'X/=' for faster processing.\n")
-                break
-            if count>100:
-                print(f"No tags detected in {each_bam.split('/')[-1]}. Processing without tags...")
-                print("Include the CS tag, MD tag, or CIGAR tag with 'X/=' for faster processing.\n")
-                break
-                # sys.exit()
-        aln_file.close()
-        srs = False
-        if length/count < 350:
-            print('Short reads detected... Processing in short-read mode.')
-            srs = True
-        else: print('Long reads detected... Processing in long-read mode.')
-        
+    parser.add_argument('-h', '--help', action='store_true', help="Print help")
+    parser.add_argument('-v', '--version', action='version', version=f'ATaRVa version {__version__}', help="Print version")
 
-        if not args.vcf:
-            out_file = f'{".".join(each_bam.split("/")[-1].split(".")[:-1])}'
-        elif mbso or (out_file[-1]=='/'):
-            out_file = out_file + '_' + ".".join(each_bam.split("/")[-1].split('.')[:-1])
+    subparsers = parser.add_subparsers(dest="command")
 
-        
+    genotype_parser(subparsers)
+    merge_parser(subparsers)
 
-        if threads > 1:
-            thread_pool = list()
-            # initializing threads
-            for tidx in range(threads):
-                contig = fetcher[tidx]
-                if srs:
-                    thread_x = Process(
-                        target = mini_cooper,
-                        args = (each_bam, args.regions, args.fasta, aln_format, contig, args.map_qual, out_file, seq_platform, args.snp_qual, args.snp_count, args.snp_dist, args.max_reads, args.min_reads, args.snp_read, args.phasing_read, tidx, args.flank, args.debug_mode, karyotype_list[kidx]))
-                else:
-                    thread_x = Process(
-                        target = cooper,
-                        args = (each_bam, args.regions, args.fasta, aln_format, contig, args.map_qual, out_file, seq_platform, args.snp_qual, args.snp_count, args.snp_dist, args.max_reads, args.min_reads, args.snp_read, args.phasing_read, tidx, args.flank, args.debug_mode, karyotype_list[kidx]))
-                thread_x.start()
-                thread_pool.append(thread_x)
-            # joining Threads 
-            for tidx, thread_x in enumerate(thread_pool):
-                thread_x.join()
-            # emptying thread_pool
-            thread_pool.clear()
-        
-            out = open(f'{out_file}.vcf', 'a')
-            print('Concatenating thread outputs!', file=sys.stderr)
-            for tidx in range(threads)[1:]:
-                thread_out = f'{out_file}_thread_{tidx}.vcf'
-                with open(thread_out, 'r') as fh:
-                    # if tidx!=0: next(fh)
-                    for line in fh:
-                        repeat_info = line.strip().split('\t')
-                        print(*repeat_info, file=out, sep='\t')
-                os.remove(thread_out)
-            out.close()
-            print('Concatenation completed!! ^_^', file=sys.stderr)
+    args = parser.parse_args()
 
-            if args.debug_mode:
-                out_log = open(f'{out_file}_debug.log', 'a')
-                for tidx in range(threads)[1:]:
-                    thread_log_out = f'{out_file}_debug_{tidx}.log'
-                    with open(thread_log_out, 'r') as fh:
-                        for line in fh:
-                            log_info = line.strip()
-                            print(log_info, file=out_log)
-                    os.remove(thread_log_out)
-                out_log.close()
-        else:
-            if srs:
-                mini_cooper(each_bam, args.regions, args.fasta, aln_format, fetcher[0], args.map_qual, out_file, seq_platform, args.snp_qual, args.snp_count, args.snp_dist, args.max_reads, args.min_reads, args.snp_read, args.phasing_read, -1, args.flank, args.debug_mode, karyotype_list[kidx])
-            else:
-                cooper(each_bam, args.regions, args.fasta, aln_format, fetcher[0], args.map_qual, out_file, seq_platform, args.snp_qual, args.snp_count, args.snp_dist, args.max_reads, args.min_reads, args.snp_read, args.phasing_read, -1, args.flank, args.debug_mode, karyotype_list[kidx])
+    if args.command is None:
+        print("Usage:")
+        print("    atarva [OPTIONS] <COMMAND>\n")
+        print("Commands:")
+        for name, sp in subparsers.choices.items():
+            print(f"  {name:<9} {sp.description}")
+        print("\nOptions:")
+        print("  -h, --help     Print help")
+        print("  -v, --version  Print version")
+        print(contact)
+        sys.exit()
 
-    time_now = ti.default_timer()
-    sys.stderr.write('CPU time: {} seconds\n'.format(time_now - start_time))
+    args.func(args)
 
 if __name__ == '__main__':
-    main()
\ No newline at end of file
+    main()
diff --git a/ATARVA/cstag_utils.py b/ATARVA/cstag_utils.py
index 34a8017..d0817a4 100644
--- a/ATARVA/cstag_utils.py
+++ b/ATARVA/cstag_utils.py
@@ -1,108 +1,112 @@
-import bisect
+from ATARVA.md_utils import update_snps
 from ATARVA.operation_utils import match_jump, deletion_jump, insertion_jump
+from ATARVA.md_utils import update_snps
 
+import numpy as np
 
-def parse_cstag(read_index, cs_tag, read_start, loci_keys, loci_coords, read_loci_variations,
-                homopoly_positions, global_read_variations, global_snp_positions, read_sequence, read_quality, cigar_one, sorted_global_snp_list, left_flank_list, right_flank_list, male):
+def parse_cstag(cooper, read):
     """
     Parse the CS tag for a read and record the variations observed for the read also for the loci
+
+    :param cooper: ATaRVa object
+    :param read: pysam AlignedSegment object
     """
-    if sorted_global_snp_list == None:
-        sorted_global_snp_list = []
+
+    if cooper.cooper_sorted_snps == None: cooper.cooper_sorted_snps = []
     operations = {':', '-', '+', '*', '=', '~'}
-    rpos = read_start   # NOTE: The coordinates are 1 based in SAM
-    qpos = 0            # starts from 0 the sub string the read sequence in python
-
-    locus_qpos_range = []
-    loci_flank_qpos_range = []
-    out_insertion_qpos_ranges_left = []
-    out_insertion_qpos_ranges_right = []
-    left_ins_rpos = []
-    right_ins_rpos = []
-    for _ in loci_coords:
-        locus_qpos_range.append([0,0])
-        loci_flank_qpos_range.append([0,0])
-        out_insertion_qpos_ranges_left.append([])
-        out_insertion_qpos_ranges_right.append([])
-        left_ins_rpos.append([])
-        right_ins_rpos.append([])
 
+    rpos = read.ref_start   # NOTE: The coordinates are 1 based in SAM
+    qpos = 0                # starts from 0 the sub string the read sequence in python
+
+    chrom = read.chrom
     repeat_index = 0
-    tracked = [False] * len(loci_coords)        
 
-    flank_track = [[False,False] for _ in loci_coords]
+    locus_query_range = np.zeros((len(read.loci_coords), 2), dtype=int)
+    flank_query_range = np.zeros((len(read.loci_coords), 2), dtype=int)
+    left_flank_insertions  = [[] for _ in read.loci_coords] # stores insertions in left flank as (rpos, qstart, qend)
+    right_flank_insertions = [[] for _ in read.loci_coords] # stores insertions in right flank as (rpos, qstart, qend)
+    locus_reached = [False for _ in read.loci_coords]
+    locus_boundary_crossed = [[False,False] for _ in read.loci_coords]
 
-    if cigar_one[0] == 4:
-        qpos+=cigar_one[1]
+    insert_positions = {}
+    if read.cigartuples[0][0] == 4:     # adjust of softclip
+        qpos += read.cigartuples[0][1]
 
-    i = 0; cs_len = len(cs_tag)
-    while i<cs_len:
+    i = 0; cs_len = len(read.cs_tag)
+    while i < cs_len:
 
-        if cs_tag[i] == ':':        # sequence match in short CS is followed by the length of match
-            match_len = '0'; i += 1
-            while i < cs_len and cs_tag[i] not in operations:
-                match_len += cs_tag[i]; i += 1
+        if read.cs_tag[i] == ':':        # sequence match in short CS is followed by the length of match
+            match_len = ''; i += 1
+            while i < cs_len and read.cs_tag[i] not in operations:
+                match_len += read.cs_tag[i]; i += 1
 
             match_len = int(match_len)
             qpos += match_len; rpos += match_len
-            repeat_index += match_jump(rpos, repeat_index, loci_coords, tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range,
+                                       locus_reached, locus_boundary_crossed)
 
-        elif cs_tag[i] == '=':      # sequence match in long CS is followed by nucs which are matching       
+        elif read.cs_tag[i] == '=':      # sequence match in long CS is followed by nucs which are matching       
             match_len = 0
-            while i < cs_len and cs_tag[i] not in operations:
+            while i < cs_len and read.cs_tag[i] not in operations:
                 match_len += 1; i += 1
 
             qpos += match_len; rpos += match_len
-            repeat_index += match_jump(rpos, repeat_index, loci_coords, tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range,
+                                       locus_reached, locus_boundary_crossed)
 
-        elif cs_tag[i] == '*':      # substitution of a base; is followed by reference and substituted base
-            ref_nuc = cs_tag[i+1]; sub_nuc = cs_tag[i+2]
+
+        elif read.cs_tag[i] == '*':      # substitution of a base; is followed by reference and substituted base
+            ref_nuc, sub_nuc = read.cs_tag[i+1], read.cs_tag[i+2]
             i += 3
 
-            if not male:
-                Q_value = read_quality[qpos]
-                global_read_variations[read_index]['snps'].add(rpos)
-                
-                if rpos not in global_snp_positions:
-                    global_snp_positions[rpos] = { 'cov': 1, sub_nuc: {read_index}, 'Qval': {read_index:Q_value} }
-                    bisect.insort(sorted_global_snp_list, rpos)
-                else:
-                    global_snp_positions[rpos]['cov'] += 1
-                    global_snp_positions[rpos]['Qval'][read_index] = Q_value
-                    if sub_nuc in global_snp_positions[rpos]: 
-                        global_snp_positions[rpos][sub_nuc].add(read_index)
-
-                    else: global_snp_positions[rpos][sub_nuc] = {read_index}
-            
-            qpos += 1; rpos += 1; match_len = 1
-            repeat_index += match_jump(rpos, repeat_index, loci_coords, tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            match_len = 1
+            update_snps(cooper, read, rpos, qpos, insert_positions, False)
 
-        elif cs_tag[i] == '+':      # insertion; is followed by the inserted bases
-            insert = ''; insert_length = 0; i += 1
-            while i < cs_len and cs_tag[i] not in operations:
-                insert += cs_tag[i]; insert_length += 1 
+            qpos += match_len; rpos += match_len
+            repeat_index += match_jump(read, rpos, qpos, match_len, repeat_index, locus_query_range, flank_query_range,
+                                       locus_reached, locus_boundary_crossed)
+
+        elif read.cs_tag[i] == '+':      # insertion; is followed by the inserted bases
+            insert = ''; insert_len = 0; i += 1
+            while i < cs_len and read.cs_tag[i] not in operations:
+                insert += read.cs_tag[i]; insert_len += 1 
                 i += 1
-            qpos += insert_length
-            repeat_index += insertion_jump(insert_length, insert, rpos, repeat_index, loci_keys,
-                                           tracked, loci_coords, homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list, out_insertion_qpos_ranges_left, out_insertion_qpos_ranges_right, left_ins_rpos, right_ins_rpos)
-
-        elif cs_tag[i] == '-':      # deletion; is followed by the deleted bases
-            deletion = ''; deletion_length = 0; i += 1
-            while i < cs_len and cs_tag[i] not in operations:
-                deletion += cs_tag[i]; deletion_length += 1
+
+            insert_positions[rpos] = insert_len
+            homopolymer_insert = False
+            if len(set(read.query_sequence[qpos:qpos+insert_len])) == 1: homopolymer_insert = True
+
+            qpos += insert_len
+            repeat_index += insertion_jump(read, rpos, qpos, insert_len, homopolymer_insert, repeat_index, locus_query_range, flank_query_range,
+                                           locus_reached, locus_boundary_crossed, left_flank_insertions, right_flank_insertions)
+
+        elif read.cs_tag[i] == '-':      # deletion; is followed by the deleted bases
+            deletion = ''; deletion_len = 0; i += 1
+            while i < cs_len and read.cs_tag[i] not in operations:
+                deletion += read.cs_tag[i]; deletion_len += 1
                 i += 1
-            if not male:
-                global_read_variations[read_index]['dels'] |= set(range(rpos, rpos+deletion_length))
-            rpos += deletion_length
-            repeat_index += deletion_jump(deletion_length, rpos, repeat_index, loci_keys, tracked, loci_coords,
-                                          homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank_list, right_flank_list)
+            if not cooper.haploid:
+                cooper.cooper_read_data[read.index].dels.extend([rpos, rpos + deletion_len])
+            rpos += deletion_len
+            repeat_index += deletion_jump(read, rpos, qpos, deletion_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed)
+
             
-    for idx,each_key in enumerate(loci_keys):
-        s_pos = locus_qpos_range[idx][0]
-        e_pos = locus_qpos_range[idx][1]
-        
-        loci_flank_qpos_range[idx][0] = loci_flank_qpos_range[idx][0] - s_pos
-        loci_flank_qpos_range[idx][1] = loci_flank_qpos_range[idx][1] - s_pos
-        ins_left = [(each_tuple[0]-s_pos, each_tuple[1]-s_pos) for each_tuple in out_insertion_qpos_ranges_left[idx]]
-        ins_right = [(each_tuple[0]-s_pos, each_tuple[1]-s_pos) for each_tuple in out_insertion_qpos_ranges_right[idx]]
-        read_loci_variations[each_key]['seq'] = [read_sequence[s_pos:e_pos], loci_flank_qpos_range[idx], ins_left, ins_right, left_ins_rpos[idx], right_ins_rpos[idx]]
\ No newline at end of file
+    num_read_loci = len(read.loci_coords)
+    for idx, locus_key in enumerate(read.loci_keys):
+        # changing all the query coordinates to be relative to the start of the flank start
+        flank_query_start = flank_query_range[idx][0]
+        if idx == 0: read.methyl_start = flank_query_start
+
+        flank_query_end = flank_query_range[idx][1]
+        if idx == num_read_loci - 1: read.methyl_end = flank_query_end
+
+        locus_query_range[idx][0] = locus_query_range[idx][0] - flank_query_start
+        locus_query_range[idx][1] = locus_query_range[idx][1] - flank_query_start
+
+        left_flank_insertions[idx]  = [(coords[0], coords[1] - flank_query_start, coords[2] - flank_query_start) for coords in left_flank_insertions[idx] ]
+        right_flank_insertions[idx] = [(coords[0], coords[1] - flank_query_start, coords[2] - flank_query_start) for coords in right_flank_insertions[idx] ]
+        read.loci_data[locus_key].seq = [read.query_sequence[flank_query_start:flank_query_end],
+                                         locus_query_range[idx],
+                                         left_flank_insertions[idx],
+                                         right_flank_insertions[idx],
+                                         flank_query_start, flank_query_end]
\ No newline at end of file
diff --git a/ATARVA/darwin_libssw.so b/ATARVA/darwin_libssw.so
new file mode 100644
index 0000000..b54a50a
Binary files /dev/null and b/ATARVA/darwin_libssw.so differ
diff --git a/ATARVA/decompose.py b/ATARVA/decompose.py
new file mode 100644
index 0000000..23fc8be
--- /dev/null
+++ b/ATARVA/decompose.py
@@ -0,0 +1,666 @@
+from collections import Counter
+from bitarray import bitarray
+import regex as re
+import warnings
+
+divisor_dict = {2:[1], 3:[1], 4:[1,2], 5:[1], 6:[1,2,3], 7:[1], 8:[1,2,4], 9:[1,3], 10:[1,2,5]}
+
+cyclic_motif_registry = {}
+
+def is_valid_repeat_block(s):
+
+    if not s.startswith('('):
+        return False
+    if ')' not in s:
+        return False
+    close = s.find(')')
+    if close <= 1:
+        return False
+    return s[close+1:].isdigit()
+
+
+def get_repeat_components(s):
+
+    close = s.index(')')
+    motif = s[1:close]
+    count = int(s[close+1:])
+    return motif, count
+
+def get_cyclic_variants(motif):
+    n = len(motif)
+    return [motif[i:] + motif[:i] for i in range(n)]
+
+def get_canonical_motif(motif):
+    return min(get_cyclic_variants(motif))
+
+def register_and_get_motif(motif):
+    if not motif or len(motif) == 0:
+        return motif
+    
+    canonical = get_canonical_motif(motif)
+    
+    if canonical not in cyclic_motif_registry:
+        cyclic_motif_registry[canonical] = motif
+        return motif
+    else:
+        return cyclic_motif_registry[canonical]
+
+
+def convert_to_bitset(seq):
+    lbit = {'A': '0', 'C': '0', 'G': '1', 'T': '1', 'N': '1'}
+    rbit = {'A': '0', 'C': '1', 'G': '0', 'T': '1', 'N': '1'}
+    
+    lbitseq = bitarray()
+    rbitseq = bitarray()
+    
+    for s in seq:
+        lbitseq.extend(lbit.get(s, '1'))
+        rbitseq.extend(rbit.get(s, '1'))
+    
+    return lbitseq, rbitseq
+
+def shift_and_match(seq):
+    shift_list = []
+    # best_shift = motif_length
+    max_matches = 0
+
+    shift_values = set(range(1, 11))
+
+    for shift in sorted(shift_values):
+        if shift < 1:
+            continue
+
+        lbitseq, rbitseq = convert_to_bitset(seq)
+
+        lmatch = ~(lbitseq ^ (lbitseq >> shift))
+        rmatch = ~(rbitseq ^ (rbitseq >> shift))
+        match = lmatch & rmatch
+        shift_list.append(match)
+
+    return shift_list
+
+def kmp_search_non_overlapping(text, pattern):
+    def compute_lps(pattern):
+        lps = [0] * len(pattern)
+        length = 0
+        i = 1
+        while i < len(pattern):
+            if pattern[i] == pattern[length]:
+                length += 1
+                lps[i] = length
+                i += 1
+            else:
+                if length != 0:
+                    length = lps[length - 1]
+                else:
+                    lps[i] = 0
+                    i += 1
+        return lps
+
+    lps = compute_lps(pattern)
+    result = []
+    i = 0
+    j = 0  
+
+    while i < len(text):
+        if pattern[j] == text[i]:
+            i += 1
+            j += 1
+
+        if j == len(pattern):  
+            result.append(i - j)
+            j = 0  
+        elif i < len(text) and pattern[j] != text[i]:
+            if j != 0:
+                j = lps[j - 1]
+            else:
+                i += 1
+
+    return result
+
+def get_most_frequent_motif(sequence, motif_size, motif):
+    cyc_motif = get_canonical_motif(motif) if motif else None
+    if len(sequence) < motif_size:  
+        return sequence, None  
+
+    repeating_units = [sequence[i:i + motif_size] for i in range(len(sequence) - motif_size + 1)]
+    motif_counts = Counter(repeating_units)
+    
+    
+    if not motif_counts:  
+        return sequence, None  
+
+    most_common = []
+    for each_motif,count in motif_counts.most_common():
+        if len(most_common) >=2: break
+        if get_canonical_motif(each_motif) == cyc_motif:
+            if motif not in most_common: most_common.append(motif)
+        else:
+            most_common.append(each_motif)
+
+    primary_motif = most_common[0] if most_common else sequence
+    primary_motif = register_and_get_motif(primary_motif)
+    secondary_motif = most_common[1] if len(most_common) > 1 else None
+
+    return primary_motif, secondary_motif
+
+def max_match(shift_list, gap_regions, motif_size):
+    gap_wise_shift = []
+    
+    for start, end in gap_regions:
+        gap_length = end - start
+        
+        candidate_shifts = []
+        
+        for idx, shift_pattern in enumerate(shift_list):
+            if not shift_pattern.any():
+                continue
+                
+            shift_value = idx + 1
+            
+            if shift_value * 2 > gap_length:  
+                continue
+                
+            sub_pattern = shift_pattern[start:end]
+            if len(sub_pattern) == 0:
+                continue
+            
+            total_matches = sub_pattern.count()
+            
+            pattern_str = sub_pattern.to01()
+            max_consecutive = max(len(run) for run in pattern_str.split('0')) if '1' in pattern_str else 0
+            ideal_consecutive = max_consecutive + shift_value
+            
+            # Score based on multiple factors
+            #score = (match_density * 0.4) + (max_consecutive / gap_length * 0.4) + (1.0 / shift_value * 0.2)
+            
+            candidate_shifts.append((shift_value, ideal_consecutive, total_matches))
+        
+        candidate_shifts.sort(key=lambda x: x[1], reverse=True)
+        
+        best_shift = -1
+               
+        for shift_value, ideal_consecutive, total_matches in candidate_shifts:
+            #repeat_runs = max_consecutive / shift_value
+            if ( ideal_consecutive / shift_value) >= 2.0:
+                best_shift = shift_value
+                break
+        
+        gap_wise_shift.append(best_shift)
+    
+    return gap_wise_shift
+    
+slide_threshold = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8, 9:9, 10:10}
+def window_scan(shift_list, motif_size, sequence, sequential_decomp, sequential_part, overall_boundary, current_gap):
+    shift_seq = shift_list[motif_size-1]#[current_gap[0]:current_gap[1]]
+
+    slide_size = slide_threshold.get(motif_size, 8)
+    # slide_size = motif_size
+    
+    i=current_gap[0]
+    start = i; end = current_gap[1]
+    start_track = start
+    initial = True
+    while i<(current_gap[1]-slide_size + 1):
+        words = shift_seq[i:i+slide_size]
+
+        if (words.count()/len(words)) >= 0.9:
+            if initial:
+                calc_start = i-motif_size if i-motif_size >= start_track else start_track
+                if calc_start>-1:
+                    for b in overall_boundary:
+                        if not (b[0] <= calc_start < b[1]):
+                            pass
+                        else:
+                            start = b[1]
+                            break
+                    else:
+                        start = calc_start
+                else:
+                    start = i #i-motif_size if i-motif_size > -1 else i
+                initial = False
+            end = i+motif_size
+            i+=motif_size
+
+            continue
+
+        else:
+            i+=1
+            if not initial:
+                calc_end = end+motif_size
+                for b in overall_boundary:
+                    if (start< calc_end <= b[0]) or (calc_end > start >= b[1]):
+                        pass
+                    else:
+                        end = b[0]
+                        break
+                else:
+                    end = calc_end    
+                if start!=end:
+                    start_track = decomposer([start, end], sequence, motif_size, sequential_decomp, sequential_part, shift_list, overall_boundary)
+                initial = True
+    if not initial:
+        calc_end = end+motif_size
+        for b in overall_boundary:
+            if (start< calc_end <= b[0]) or (calc_end > start >= b[1]):
+                pass
+            else:
+                end = b[0]
+                break
+        else:
+            end = calc_end 
+        if start!=end:
+            start_track = decomposer([start, end], sequence, motif_size, sequential_decomp, sequential_part, shift_list, overall_boundary)
+
+
+def shift_decomp(seq, motif_size, motif, boundary, state):
+    decomposed_parts = []
+    count = 1  
+    
+    primary_motif, _ = get_most_frequent_motif(seq, motif_size, motif)
+    
+    positions = kmp_search_non_overlapping(seq, primary_motif)
+    
+    if not positions:
+        return [seq], boundary
+
+
+    seq = seq[positions[0] : positions[-1]+motif_size]
+    
+    if state:
+        b1 = boundary[0]
+        boundary = [b1+positions[0], b1+positions[-1]+motif_size]
+
+        
+    for i in range(1, len(positions)):
+        if positions[i] == positions[i - 1] + len(primary_motif):
+            count += 1
+        else:
+            if count > 1:
+                decomposed_parts.append(f"({primary_motif}){count}")
+            else:
+                decomposed_parts.append(primary_motif)
+            interspersed = seq[positions[i - 1] + len(primary_motif):positions[i]]
+            if interspersed:
+                primary_motif, secondary_motif = get_most_frequent_motif(seq, motif_size, '')
+                secondary_decomp, boundary = shift_decomp(interspersed, motif_size, '', boundary, False)
+                if secondary_decomp:
+                    decomposed_parts.extend(secondary_decomp)
+
+            count = 1
+            
+    if count > 1:
+        decomposed_parts.append(f"({primary_motif}){count}")
+    else:
+        decomposed_parts.append(primary_motif)
+    last_motif_end = positions[-1] + len(primary_motif)
+    leftover_sequence = seq[last_motif_end:]
+    if leftover_sequence:
+        decomposed_parts.append(leftover_sequence)
+    return decomposed_parts, boundary
+
+def decomposer(tuple_bound, sequence, best_shift, sequential_decomp, sequential_part, shift_list, overall_boundary):
+    processed_seq, tuple_bound = shift_decomp(sequence[tuple_bound[0]:tuple_bound[1]], best_shift, '', tuple_bound, True)
+    b1 = tuple_bound[0]; b2 = tuple_bound[1]
+    sequential_decomp[b1] = processed_seq
+    sequential_part[b1:b2] = 0
+    for id in range(len(shift_list)):
+        if shift_list[id] == 0: continue
+        shift_list[id][b1:b2] = 0
+    overall_boundary.append(tuple_bound)
+    return b2
+
+def gap_boundaries(overall_boundary, seq_len, chunk_state):
+    overall_boundary = sorted(overall_boundary)
+
+    if chunk_state and len(overall_boundary)>=1:
+        if len(overall_boundary)>1:
+            chunk_boundary = overall_boundary[0][0]
+            chunk_boundary_end = overall_boundary[-1][1]
+        else:
+            chunk_boundary = overall_boundary[0][0]
+            chunk_boundary_end = seq_len
+    else:
+        chunk_boundary = 0
+        chunk_boundary_end = seq_len
+        
+    last_start = overall_boundary[-1][0]
+    gap_regions = []
+    for id,occupied_reg in enumerate(overall_boundary):
+    
+        if id == 0:
+            current_end = occupied_reg[1]
+            if occupied_reg[0] != chunk_boundary:
+                gap_regions.append([chunk_boundary, occupied_reg[0]])
+            elif len(overall_boundary) == 1:
+                if occupied_reg[1] <= (seq_len-1):
+                    gap_regions.append([occupied_reg[1],seq_len])
+                    current_end = seq_len
+            
+    
+        else:
+            if occupied_reg[0] != current_end:
+                gap_regions.append([current_end, occupied_reg[0]])
+            current_end = occupied_reg[1]
+
+            
+    if current_end < chunk_boundary_end:
+        gap_regions.append([current_end, chunk_boundary_end])
+
+    return gap_regions
+
+def motif_decomposition(sequence, motif_size):
+
+    global cyclic_motif_registry
+    cyclic_motif_registry = {}
+    
+
+    shift_list = shift_and_match(sequence)
+    overall_boundary = []
+    sequential_decomp = {}
+    sequential_part = bitarray([1]*len(sequence))
+    seq_len = len(sequence)
+    gap_regions = [[0, seq_len]]
+    rounds = 0
+    while any(sequential_part):
+        if rounds == 1:
+            shift_list[0][:] = 0
+            
+        if (rounds==0) and (motif_size==1):
+            gap_wise_shift = [1]
+        else:
+            gap_wise_shift = max_match(shift_list, gap_regions, motif_size)
+
+        for index, best_shift in enumerate(gap_wise_shift):
+            
+            current_gap = gap_regions[index]
+            
+            if best_shift!=-1:
+                previous_ovbound = overall_boundary.copy()
+                window_scan(shift_list, best_shift, sequence, sequential_decomp, sequential_part, overall_boundary, current_gap)
+                if previous_ovbound == overall_boundary:
+ 
+                    c1 = current_gap[0]; c2 = current_gap[1]
+                    covered_chunks = [i for i in overall_boundary if (i[0]>=c1 and i[1]<=c2) or ((i[1]==c1) or (i[0]==c2))]
+
+                    if covered_chunks == []:
+                        sequential_part[c1 : c2] = 0
+                        sequential_decomp[c1] = [sequence[c1 : c2]]
+                        overall_boundary.append([c1,c2])
+                        continue
+
+                    gap_in_chunks = gap_boundaries(covered_chunks, c2, True)
+                    if not gap_in_chunks:
+                        if (c1 == 0) or (c2 == seq_len):
+                            gap_in_chunks = [current_gap]
+
+                    for each_gap in gap_in_chunks:
+                        sequential_part[each_gap[0] : each_gap[1]] = 0
+                        for shift_id in range(len(shift_list)):
+                            shift_list[shift_id][each_gap[0] : each_gap[1]] = 0
+                        sequential_decomp[each_gap[0]] = [sequence[each_gap[0] : each_gap[1]]]
+
+                        overall_boundary.append([each_gap[0] , each_gap[1]])
+
+                
+            else:
+                if sequence[current_gap[0] : current_gap[1]]:
+                    sequential_decomp[current_gap[0]] = [sequence[current_gap[0] : current_gap[1]] ]
+                sequential_part[current_gap[0] : current_gap[1]] = 0
+                overall_boundary.append([current_gap[0] , current_gap[1]])
+
+        gap_regions = gap_boundaries(overall_boundary, seq_len, False)
+
+        rounds += 1
+        if rounds >= 20 :
+            warnings.warn("Max rounds reached; decomposition may be incomplete")
+        
+    fseq = [i for k,v in sorted(sequential_decomp.items(), key = lambda x : x[0]) for i in v]
+
+    if len(fseq)==1:
+        if '(' in fseq[0]:
+            non_rep_percent = 0
+        else:
+            non_rep_percent=1
+    else:
+        fseq, non_rep_percent = refine_decomposition(fseq, motif_size, len(sequence))
+
+    return ["-".join(fseq), non_rep_percent]
+
+def refine_decomposition(fseq, motif_size, seq_len):
+
+    
+    new_seq_list = []
+    non_repeat = 0
+    
+    for i in fseq:
+        if '(' in i and ')' in i:  # refining only the decomposed parts
+            try:
+                end_point = i.index(')')
+                count = int(i[end_point+1:])
+                tmp_motif = i[1:end_point]
+                motif_len = len(tmp_motif)
+                
+                if len(set(tmp_motif)) == 1:
+                    new_seq_list.append(f'({tmp_motif[0]}){motif_len*count}')
+                
+                elif (motif_len % 2 == 0):  
+                    mid_point = int(motif_len/2)
+                    if tmp_motif[0: mid_point] == tmp_motif[mid_point:]:
+                        check_motif = tmp_motif[0: mid_point]
+                        new_seq_list.append(f'({check_motif}){count*2}')
+                    else:
+                        new_seq_list.append(i)
+                        
+                elif motif_len <= motif_size:  
+                    new_seq_list.append(i)
+                        
+                elif (motif_len != 1) and (motif_len > motif_size) and (motif_len % motif_size == 0):
+                    for div in divisor_dict.get(motif_len, [1]):
+                        check_motif = tmp_motif[:div]
+                        e = 0
+                        pattern = "(" + check_motif + "){e<=" + str(e) + "}"
+                        matches = re.finditer(pattern, tmp_motif, overlapped=False)
+                        tot_rep = sum(1 for _ in matches)
+                        if tot_rep * len(check_motif) == motif_len:
+                            motif_count = tot_rep * count
+                            new_seq_list.append(f'({check_motif}){motif_count}')
+                            break
+                    else:
+                        new_seq_list.append(i)
+                else:
+                    new_seq_list.append(i)
+            except (ValueError, IndexError):
+                new_seq_list.append(i)
+        else:
+
+            segment = i
+            decomposed_segment = []
+            
+            pos = 0
+            while pos < len(segment):
+                found_repeat = False
+                
+                for test_len in range(motif_size, min(6, len(segment) - pos) + 1):
+                    if test_len == 0:
+                        continue
+                    
+                    test_motif = segment[pos:pos+test_len]
+                    
+                    count = 1
+                    next_pos = pos + test_len
+                    
+                    while next_pos + test_len <= len(segment) and segment[next_pos:next_pos+test_len] == test_motif:
+                        count += 1
+                        next_pos += test_len
+                    
+                    if count >= 2:
+                        decomposed_segment.append(f'({test_motif}){count}')
+                        pos = next_pos
+                        found_repeat = True
+                        break
+                
+                if not found_repeat:
+
+                    remaining_len = len(segment) - pos
+                    if remaining_len <= motif_size:
+                        decomposed_segment.append(segment[pos:])
+                        break
+                    else:
+                        chunk_size = min(motif_size, remaining_len)
+                        decomposed_segment.append(segment[pos:pos+chunk_size])
+                        pos += chunk_size
+            
+            if len(decomposed_segment) > 1 or (len(decomposed_segment) == 1 and '(' in decomposed_segment[0]):
+                new_seq_list.extend(decomposed_segment)
+            else:
+                new_seq_list.append(i)
+                non_repeat += len(i)
+
+    
+    dlen = len(new_seq_list) - 1
+    loc = 0
+    tmp_loc = 1 # different value then 'loc' to start the loop
+    refined_list = []
+    
+    while loc < dlen:
+        if tmp_loc != loc:
+            current = new_seq_list[loc]
+        else:
+            loc += 1
+            if (loc == dlen) and current:
+                refined_list.append(current)
+                loc += 1
+                break
+        tmp_loc = loc
+        next_item = new_seq_list[loc+1]
+
+        current_state = 1 if '(' in current and ')' in current else 0
+        next_state = 1 if '(' in next_item and ')' in next_item else 0
+        
+        if current_state == 1 and next_state == 1:
+            try:
+                e1 = current.index(')')
+                e2 = next_item.index(')')
+                tmp1 = current[1:e1]
+                tmp2 = next_item[1:e2]
+                
+                if tmp1 == tmp2:  
+                    combined_count = int(current[e1+1:]) + int(next_item[e2+1:])
+                    refined_list.append(f'({tmp1}){combined_count}')
+                    loc += 2
+                else:
+                    refined_list.append(current)
+                    loc += 1
+            except (ValueError, IndexError):
+                refined_list.append(current)
+                loc += 1
+                
+        elif current_state == 1 and next_state == 0:
+            try:
+                e1 = current.index(')')
+                tmp1 = current[1:e1]
+                
+                if len(next_item) >= len(tmp1) and tmp1 == next_item[0:len(tmp1)]:
+                    combined_count = int(current[e1+1:]) + 1
+                    remaining = next_item[len(tmp1):]
+
+                    while tmp1 == remaining[0:len(tmp1)]:
+                        combined_count += 1 
+                        remaining = remaining[len(tmp1):]
+                        if (len(remaining)==1) and tmp1 == remaining:
+                            combined_count += 1
+                            remaining = ''
+                            break
+                    
+                    refined_list.append(f'({tmp1}){combined_count}')
+                    
+                    if remaining:
+                        current = remaining
+                        loc += 1
+                    else:
+                        loc += 2
+                        
+                elif tmp1 == next_item:  
+                    combined_count = int(current[e1+1:]) + 1
+                    refined_list.append(f'({tmp1}){combined_count}')
+                    loc += 2
+                else:
+                    refined_list.append(current)
+                    loc += 1
+                    
+            except (ValueError, IndexError):
+                refined_list.append(current)
+                loc += 1
+                
+        elif current_state == 0 and next_state == 1:
+            try:
+                e2 = next_item.index(')')
+                tmp2 = next_item[1:e2]
+                
+                if len(current) >= len(tmp2) and tmp2 == current[len(current)-len(tmp2):]:
+                    combined_count = int(next_item[e2+1:]) + 1
+                    
+                    beginning = current[:len(current)-len(tmp2)]
+                    if beginning:
+                        refined_list.append(beginning)
+                    
+                    refined_list.append(f'({tmp2}){combined_count}')
+                    loc += 2
+                elif tmp2 == current:  
+                    combined_count = int(next_item[e2+1:]) + 1
+                    refined_list.append(f'({tmp2}){combined_count}')
+                    loc += 2
+                else:
+                    refined_list.append(current)
+                    loc += 1
+            except (ValueError, IndexError):
+                refined_list.append(current)
+                loc += 1
+                
+        else:
+            current = current + next_item
+
+    
+    if loc == dlen:
+        refined_list.append(new_seq_list[loc])
+    
+    final_merged = []
+    i = 0
+    while i < len(refined_list):
+        if i < len(refined_list) - 1:
+            current = refined_list[i]
+            next_item = refined_list[i+1]
+            
+            if '(' in current and ')' in current and '(' in next_item and ')' in next_item:
+                try:
+                    e1 = current.index(')')
+                    e2 = next_item.index(')')
+                    tmp1 = current[1:e1]
+                    tmp2 = next_item[1:e2]
+                    
+                    if tmp1 == tmp2:
+                        combined_count = int(current[e1+1:]) + int(next_item[e2+1:])
+                        final_merged.append(f'({tmp1}){combined_count}')
+                        i += 2
+                        continue
+                except (ValueError, IndexError):
+                    pass
+        
+        final_merged.append(refined_list[i])
+        i += 1
+    
+    non_repeat_len = 0
+    for elem in final_merged:
+        if '(' in elem and ')' in elem:
+            try:
+                end_point = elem.index(')')
+                pass
+            except ValueError:
+                non_repeat_len += len(elem)
+        else:
+            non_repeat_len += len(elem)
+    
+    non_rep_percent = round((non_repeat_len / seq_len), 2) if seq_len > 0 else 0
+    
+    return final_merged, non_rep_percent
\ No newline at end of file
diff --git a/ATARVA/genotype.py b/ATARVA/genotype.py
new file mode 100644
index 0000000..5570d1c
--- /dev/null
+++ b/ATARVA/genotype.py
@@ -0,0 +1,298 @@
+import sys
+import os
+import timeit as ti
+from pathlib import Path
+from multiprocessing import Pool
+from tqdm import tqdm
+import pysam
+
+from ATARVA.readers       import fasta_check, bam_check, tabix_check
+from ATARVA.version       import __version__
+from ATARVA.baseline      import Cooper
+from ATARVA.readers       import *
+from ATARVA.vcf_writer    import set_info_mp_cutoff
+from ATARVA.sub_operation_utils import set_methviz_tag
+
+# --- Constants ---
+FORMAT_MAP = {
+    'cram': 'rc',
+    'sam' : 'r',
+    'bam' : 'rb'
+}
+
+DEFAULT_MAX_READS = 100
+DEFAULT_FLANK     = 10
+
+def genotype_parser(subparsers):
+    """Argument parser for the genotype sub-command of ATaRVa"""
+
+    parser = subparsers.add_parser(
+        "genotype",
+        help        = "tandem repeat genotyper for long read data",
+        description = "Tandem Repeat Genotyper"
+    )
+    parser._action_groups.pop()
+
+    req = parser.add_argument_group('Required arguments')
+    req.add_argument('-f', '--fasta',   required=True, metavar='<FILE>', help='input reference fasta file')
+    req.add_argument('-b', '--bam',     required=True, metavar='<FILE>', nargs='+',
+                     help='sample alignment files [SAM | BAM | CRAM]')
+    req.add_argument('-r', '--regions', required=True, metavar='<FILE>',
+                     help='bgzipped + tabix-indexed regions file. '
+                          'Prepare: sort with bedtools → bgzip → tabix index')
+
+    opt = parser.add_argument_group('Optional arguments')
+
+    # Input / Output
+    opt.add_argument('-o', '--vcf',      metavar='<FILE>', default='', help='output VCF file [default: stdout]')
+    opt.add_argument('--aln-format',         metavar='<STR>',  default='bam', help='alignment format [cram | bam | sam] [default: bam]')
+    opt.add_argument('--contigs',        metavar='<STR>',  nargs='+', help='contigs to genotype e.g. chr1 chr12 [default: all]')
+    opt.add_argument('--karyotype',      metavar='<STR>',  nargs='+', help='sample karyotypes e.g. XY XX')
+
+    # Read filtering
+    opt.add_argument('-q', '--map-qual', metavar='<INT>',   type=int,   default=5, help='minimum mapping quality [default: 5]')
+    opt.add_argument('--min-reads',      metavar='<INT>',   type=int,   default=10, help='minimum read coverage at a locus [default: 10]')
+    opt.add_argument('--max-reads',      metavar='<INT>',   type=int,   default=None, help='maximum reads per locus [default: 100]')
+    opt.add_argument('--flank',          metavar='<INT>',   type=int,   default=None, help='flank length (bp) to search for insertions [default: 10]')
+
+    # SNP phasing
+    opt.add_argument('--snp-dist',       metavar='<INT>',   type=int,   default=3000, help='max SNP distance from repeat [default: 3000]')
+    opt.add_argument('--snp-count',      metavar='<INT>',   type=int,   default=3, help='number of SNPs for phasing [default: 3]')
+    opt.add_argument('--snp-qual',       metavar='<INT>',   type=int,   default=20, help='min base quality at SNP position [default: 20]')
+    opt.add_argument('--snp-read',       metavar='<FLOAT>', type=float, default=0.2, help='min SNP read fraction [default: 0.2]')
+    opt.add_argument('--phasing-read',   metavar='<FLOAT>', type=float, default=0.4, help='min phased read cluster fraction [default: 0.4]')
+    opt.add_argument('--haplotag',       metavar='<STR>',               default=None, help='haplotag for phasing e.g. HP [default: None]')
+
+    # Methylation
+    opt.add_argument('--meth-prob',      metavar='<FLOAT>',  type=float, default=0.5, help='min methylation probability [default: 0.5]')
+    opt.add_argument('--methviz',        action='store_true', help='write methylation-encoded sequence to VCF [default: False]')
+
+    # Modes
+    opt.add_argument('--read-wise',      action='store_true', help='read-wise genotyping for dense BED regions')
+    opt.add_argument('--locus-wise',     action='store_true', help='locus-wise genotyping for sparse BED regions')
+    opt.add_argument('--decompose',      action='store_true', help='write motif-decomposed sequence to VCF')
+
+    # Misc
+    opt.add_argument('-t',   '--threads',      metavar='<INT>', type=int, default=1, help='number of threads [default: 1]')
+    opt.add_argument('-log', '--debug_mode', action='store_true', help='write debug messages to log file')
+    opt.add_argument('-v',   '--version',      action='version', version=f'ATaRVa version {__version__}')
+
+    if len(sys.argv) == 2 and sys.argv[1] == 'genotype':
+        parser.print_help()
+        sys.exit()
+
+    parser.set_defaults(func=genotype_run)
+
+
+def splitfile_threads(tbx, contigs, total_loci, threads):
+    """
+    split the input region file into per-thread chunks for parallel processing.
+
+    :param tbx:        pysam Tabixfile object
+    :param contigs:    list of contigs to process
+    :param total_loci: total number of loci across all contigs
+    :param threads:    number of parallel threads
+    :return:           list of region chunk tuples, one per thread
+    """
+
+    split_size  = total_loci // threads
+    if split_size == 0:
+        split_size = total_loci
+    fetcher     = []
+    line_count  = 0
+    cur_chunk   = []
+    chrom       = None
+    start_coord = None
+
+    for contig in contigs:
+        first_in_contig = True
+
+        for row in tbx.fetch(contig):
+            fields = row.split('\t')
+            line_count += 1
+
+            if first_in_contig:
+                chrom       = fields[0]
+                start_coord = (int(fields[1]), int(fields[2]))
+                first_in_contig = False
+
+            if len(fetcher) < threads - 1 and line_count % split_size == 0:
+                end_coord = (int(fields[1]), int(fields[2]))
+                cur_chunk.append([chrom, start_coord, end_coord])
+                fetcher.append(tuple(cur_chunk))
+                cur_chunk       = []
+                line_count      = 0
+                first_in_contig = True
+
+        if not first_in_contig:
+            end_coord = (int(fields[1]), int(fields[2]))
+            cur_chunk.append([chrom, start_coord, end_coord])
+
+    fetcher.append(tuple(cur_chunk)) # pad with empty chunks if needed
+    return fetcher
+
+
+def worker_init(bam_file, region_ranges, args, out_file, sample_idx, thread_idx):
+    """
+    Initialise and run a Cooper genotyping worker for a thread.
+
+    :param bam_file:      path to the alignment file
+    :param region_ranges: list of regions for this thread
+    :param args:          parsed command-line arguments
+    :param out_file:      output file path
+    :param sample_idx:    sample index
+    :param thread_idx:    thread index
+    """
+    Cooper(bam_file, region_ranges, args, out_file, sample_idx, thread_idx)
+
+
+def resolve_output_path(vcf_arg):
+    """
+    Resolve and normalise the output file path from --vcf argument.
+    :param vcf_arg: raw --vcf argument value
+    :return: resolved base output path (no extension)
+    """
+    if not vcf_arg:
+        return ''
+    path = vcf_arg.rstrip('/')
+    if path.endswith('.vcf'):
+        path = path[:-4]
+    return path
+
+
+def sample_stem(bam_path: str) -> str:
+    """Extract sample name stem from BAM file path."""
+    return Path(bam_path).stem
+
+
+def concat_thread_outputs(base_path: str, n_threads: int,
+                            debug: bool = False) -> None:
+    """
+    Concatenate per-thread VCF (and optionally log) outputs into a single file.
+
+    :param base_path: base output path (no extension)
+    :param n_threads: total number of threads
+    :param debug:     whether to also concatenate debug logs
+    """
+    parent   = Path(base_path).parent
+    stem     = Path(base_path).name
+    hidden   = parent / f'.{stem}'              # hidden prefix for thread files
+
+    # --- VCF concatenation ---
+    print('\nConcatenating thread outputs...', file=sys.stderr)
+    with open(f'{base_path}.vcf', 'a') as out_vcf:
+        for tidx in range(1, n_threads):
+            thread_vcf = f'{hidden}_thread_{tidx}.vcf'
+            with open(thread_vcf) as fh:
+                for line in fh:
+                    print(*line.strip().split('\t'), file=out_vcf, sep='\t')
+            os.remove(thread_vcf)
+            os.remove(f'{hidden}_debug_{tidx}.log')
+    print('Concatenation complete.', file=sys.stderr)
+
+    # --- log concatenation ---
+    if debug:
+        with open(f'{base_path}_debug.log', 'a') as out_log:
+            for tidx in range(1, n_threads):
+                thread_log = f'{hidden}_debug_{tidx}.log'
+                with open(thread_log) as fh:
+                    for line in fh:
+                        print(line.strip(), file=out_log)
+                os.remove(thread_log)
+
+
+def genotype_run(args) -> None:
+    """
+    Main entry point for the ATaRVa genotyping workflow.
+
+    :param args: parsed command-line arguments
+    """
+    start_time = ti.default_timer()
+
+    # --- print args ---
+    for arg in vars(args):
+        if arg not in ('func', 'help', 'command'):
+            print(arg, getattr(args, arg), file=sys.stderr)
+
+    # --- file validation ---
+    fasta_check(args.fasta)
+    tabix_check(args.regions)
+
+    args.aln_format = FORMAT_MAP.get(args.aln_format, 'rb')
+
+    for bam in args.bam:
+        bam_check(bam, args.aln_format)
+
+    # --- VCF output setup ---
+    set_info_mp_cutoff(args.meth_prob)
+    set_methviz_tag(args.methviz)
+
+    base_output = resolve_output_path(args.vcf)
+
+    # --- tabix region processing ---
+    tbx = pysam.Tabixfile(args.regions)
+    if not args.contigs:
+        args.contigs = sorted(tbx.contigs)
+        total_loci   = sum(1 for _ in tbx.fetch())
+    else:
+        args.contigs = sorted(args.contigs)
+        total_loci   = sum(1 for c in args.contigs for _ in tbx.fetch(c))
+
+    if total_loci < args.threads:
+        args.threads = 1
+
+    fetcher = splitfile_threads(tbx, args.contigs, total_loci, args.threads)
+    tbx.close()
+
+    # --- karyotype setup ---
+    args.karyotype = (
+        [k == 'XY' for k in args.karyotype]
+        if args.karyotype
+        else [False] * len(args.bam)
+    )
+
+    # --- mode defaults ---
+    if args.max_reads is None: args.max_reads = DEFAULT_MAX_READS
+    if args.flank     is None: args.flank     = DEFAULT_FLANK
+
+    multi_bam_single_out = len(args.bam) > 1 and args.vcf
+
+    # --- per-sample processing ---
+    for sample_idx, bam_file in enumerate(args.bam):
+        sample_name = sample_stem(bam_file)
+        print(f'Processing sample: {sample_name}\n', file=sys.stderr)
+
+        check_alnfile(bam_file, args)
+
+        # resolve per-sample output path
+        if not args.vcf:
+            out_file = sample_name
+        elif multi_bam_single_out or args.vcf.endswith('/'):
+            out_file = f'{base_output}_{sample_name}'
+        else:
+            out_file = base_output
+
+        # --- multithreaded ---
+        if args.threads > 1:
+            pbar = tqdm(total=args.threads, desc='Processing',
+                        ascii='_>', ncols=75,
+                        bar_format='{l_bar}{bar}{n_fmt}/{total_fmt}')
+            with Pool(processes=args.threads) as pool:
+                for thread_idx in range(args.threads):
+                    pool.apply_async(
+                        worker_init,
+                        args=(bam_file, fetcher[thread_idx],
+                                args, out_file, sample_idx, thread_idx),
+                        callback=lambda _: pbar.update()
+                    )
+                pool.close()
+                pool.join()
+
+            concat_thread_outputs(out_file, args.threads, debug=args.debug_mode)
+
+        # --- single threaded ---
+        else:
+            worker_init(bam_file, fetcher[0], args, out_file, sample_idx, 0)
+
+    elapsed = ti.default_timer() - start_time
+    sys.stderr.write(f'\nCPU time: {elapsed:.2f} seconds\n')
diff --git a/ATARVA/genotype_utils.py b/ATARVA/genotype_utils.py
index bc8d486..6220dc3 100644
--- a/ATARVA/genotype_utils.py
+++ b/ATARVA/genotype_utils.py
@@ -1,203 +1,63 @@
-from ATARVA.snp_utils import haplocluster_reads
-from ATARVA.vcf_writer import *
 import numpy as np
-import statistics
-from sklearn.cluster import KMeans
-import warnings
-from threadpoolctl import threadpool_limits
-
-
-def length_genotyper(hallele_counter, global_loci_info, global_loci_variations, locus_key, read_indices, contig, locus_start, locus_end, ref, out, male):
-
-    read_indices = sorted(read_indices)
-    locus_read_allele = global_loci_variations[locus_key]['read_allele']
-    
-    alen_with_1read = [item[0] for item in hallele_counter.items() if item[1]==1] # allele with 1 read contribution
-    alen_with_gread = set(hallele_counter.keys()) - set(alen_with_1read) # allele with more than 1 read contribution
-    main_read_id = []
-    alen_data = []
-    
-    for id in read_indices:
-        if locus_read_allele[id][0] in alen_with_1read: # checking if the '1 read - allele' is nearby any of other 'good read - allele'
-            num = locus_read_allele[id][0]
-            for i in alen_with_gread:
-                if i in range(num-10, num+10): # '1 read - allele' is considered if other allele are within 10 bp on either of the side
-                    alen_data.append(num)
-                    main_read_id.append(id)
-                    break
-        else:
-            alen_data.append(locus_read_allele[id][0])
-            main_read_id.append(id)
-
-    if alen_data == []:
-        return [False, 6]
-
-    data = np.array(alen_data)
-    data = data.reshape(-1, 1)
-    with threadpool_limits(limits=1):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", category=UserWarning)
-            kmeans = KMeans(n_clusters=2, init='k-means++', n_init=5, random_state=0).fit(data)
-    cluster_labels = kmeans.labels_  
-    c1 = [i for i, x in enumerate(cluster_labels) if x == 0]
-    c2 = [i for i, x in enumerate(cluster_labels) if x == 1]
-
-    haplotypes = ([main_read_id[idx] for idx in c1], [main_read_id[idx] for idx in c2])
-    cutoff = 0.15*len(alen_data) # 15%
-
-    if male:
-        cluster_len = [len(c1), len(c2)]
-        cidx = cluster_len.index(max( cluster_len ))
-        if cluster_len[cidx]>=cutoff:
-            mac = haplotypes[cidx]
-            hap_al1 = [alen_data[i] for i in [c1,c2][cidx]]
-            genotypes = statistics.mode(hap_al1)
-            hap_reads = [read_id for read_id in mac if locus_read_allele[read_id][0]==genotypes]
-            vcf_homozygous_writer(ref, contig, locus_key, global_loci_info, genotypes, global_loci_variations, hap_al1.count(genotypes), out, hap_reads)
-    
-    elif (c1!=[] and len(c1)>=cutoff) and (c2!=[] and len(c2)>=cutoff):
-        phased_read = ['.','.']
-        chosen_snpQ = '.'
-        snp_num = '.'
-        hap_al1 = [alen_data[i] for i in c1]
-        hap_al2 = [alen_data[i] for i in c2]
-        haplo_alleles = (hap_al1,hap_al2)
-        
-
-        genotypes = []
-        for alleles_set in haplo_alleles: # making the set of final alleles from two clusters
-            genotypes.append(statistics.mode(alleles_set))
-
-        hap_reads = ([],[])
-        for i,al in enumerate(genotypes):
-            hap_reads[i].extend([read_id for read_id in haplotypes[i] if locus_read_allele[read_id][0]==al])
-
-        allele_count = {}
-        for al in genotypes:
-            allele_count[al] = hallele_counter[al]
-        vcf_heterozygous_writer(contig, genotypes, locus_start, global_loci_variations, locus_end, allele_count, len(read_indices), global_loci_info, ref, out, chosen_snpQ, phased_read, snp_num, hap_reads)
-
-    elif c1!=[] and len(c1)>=cutoff:
-        hap_al1 = [alen_data[i] for i in c1]
-        genotypes = statistics.mode(hap_al1)
-        hap_reads = [read_id for read_id in haplotypes[0] if locus_read_allele[read_id][0]==genotypes]
-        vcf_homozygous_writer(ref, contig, locus_key, global_loci_info, genotypes, global_loci_variations, hap_al1.count(genotypes), out, hap_reads)
-        
-
-    elif c2!=[] and len(c2)>=cutoff:
-        hap_al2 = [alen_data[i] for i in c2]
-        genotypes = statistics.mode(hap_al2)
-        hap_reads = [read_id for read_id in haplotypes[1] if locus_read_allele[read_id][0]==genotypes]
-        vcf_homozygous_writer(ref, contig, locus_key, global_loci_info, genotypes, global_loci_variations, hap_al2.count(genotypes), out, hap_reads)
-        
-    else:
-        return [False, 6] # write allele distribution with only one read supporting to it in vcf
-    
-    return [True, 10]
-
-
-def analyse_genotype(contig, locus_key, global_loci_info,
-                     global_loci_variations, global_read_variations, global_snp_positions, hallele_counter,
-                     ref, out, sorted_global_snp_list, snpQ, snpC, snpD, snpR, phasingR, maxR, max_limit, male):
-
-    locus_start = int(global_loci_info[locus_key][1])
-    locus_end = int(global_loci_info[locus_key][2])
-
-    state = False
-
-    if max_limit == 0:
-        read_indices = global_loci_variations[locus_key]['reads']
-    else:
-        read_indices = global_loci_variations[locus_key]['reads'][:maxR]
-
-    if male: 
-        state, skip_point = length_genotyper(hallele_counter, global_loci_info, global_loci_variations, locus_key, read_indices, contig, locus_start, locus_end, ref, out, male)
-        return [state, skip_point]
-
-
-    snp_positions = set()
-    for rindex in read_indices:
-        snp_positions |= (global_read_variations[rindex]['snps'])
-
-    snp_positions = sorted(list(filter(lambda x: (x in global_snp_positions) and (global_snp_positions[x]['cov'] >= 3) and
-                                                    (locus_start - snpD < x < locus_end + snpD),
-                            snp_positions)))
 
+from ATARVA.snp_utils import haplocluster_reads
+from ATARVA.vcf_writer import *
+from ATARVA.sub_operation_utils import alt_sequence
+from ATARVA.somatic_utils import *
+from ATARVA.length_utils import *
 
-    snp_allelereads = {}
-    read_indices = set(read_indices)
-    non_ref_snp_cov = {}
-    for pos in snp_positions:
-        c_point=0
-        coverage = set()
-        non_ref_nucs = [nucleotides for nucleotides in global_snp_positions[pos] if nucleotides not in ['cov', 'Qval', 'r']]
-        for each_nuc in non_ref_nucs:
-            reads_of_nuc = global_snp_positions[pos][each_nuc].intersection(read_indices)
-            if len(reads_of_nuc) == 0: continue
-            coverage.add(len(reads_of_nuc))
+# NOTE: after genotyping and haplogrouping, before reporting the locus build the ALT sequence
+#       and calculate methylation level for the haplotypes
 
-            if (sum([global_snp_positions[pos]['Qval'][read_idx] for read_idx in reads_of_nuc])/len(reads_of_nuc)) <= 13:
-                c_point=1
-                break
-        if (len(coverage)==0) or (c_point==1): continue
-        else: non_ref_snp_cov[pos] = max(coverage)
-            
-        snp_allelereads[pos] = { 'cov': 0, 'reads': set(), 'alleles': {}, 'Qval': {} }
-        for nuc in global_snp_positions[pos]:
-            if (nuc == 'cov') or (nuc == 'Qval'): continue
-            snp_allelereads[pos]['alleles'][nuc] = global_snp_positions[pos][nuc].intersection(read_indices)
-            snp_allelereads[pos]['cov'] += len(snp_allelereads[pos]['alleles'][nuc])
-            if nuc!='r':
-                snp_allelereads[pos]['Qval'].update(dict([(read_idx,global_snp_positions[pos]['Qval'][read_idx]) for read_idx in snp_allelereads[pos]['alleles'][nuc]]))
 
-    del_positions = list(filter(lambda x: snp_allelereads[x]['cov'] < 5, snp_allelereads.keys()))
+def analyse_genotype(cooper, locus_key):
+    """
+    genotype the locus based on the read data
 
-    for pos in del_positions:
-        del snp_allelereads[pos]
+    :param cooper: Cooper object
+    :param locus_key: locus identifier string
+    """
 
+    locus      = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
 
-    ordered_snp_on_cov = sorted(snp_allelereads.keys(), key = lambda item : non_ref_snp_cov[item], reverse = True)
+    if cooper.haploid:
+        length_genotyper(cooper, locus_key)
+        return
 
+    min_snp = haplocluster_reads(cooper, locus_key)
 
-    haplotypes, min_snp, skip_point, chosen_snpQ, phased_read, snp_num = haplocluster_reads(snp_allelereads, ordered_snp_on_cov, read_indices, snpQ, snpC, snpR, phasingR) # SNP ifo and supporting reads for specific locus are given to the phasing function
+    if not locus_data.is_genotyped: # if the loci has no significant snps
+        length_genotyper_hdbscan(cooper, locus_key)
+        return
 
-    if haplotypes == (): # if the loci has no significant snps
-        state, skip_point = length_genotyper(hallele_counter, global_loci_info, global_loci_variations, locus_key, read_indices, contig, locus_start, locus_end, ref, out, male)
-        return [state, skip_point]
-    
     if min_snp != -1:
-        min_idx = sorted_global_snp_list.index(min_snp)
-        del sorted_global_snp_list[:min_idx]
-        del_snps = set()
-        for pos in global_snp_positions:
-            if pos < min_snp: del_snps.add(pos)
-        for pos in del_snps:
-            del global_snp_positions[pos]
-
-    
-    locus_read_allele = global_loci_variations[locus_key]['read_allele'] # extracting allele info from global_loci_variation
-    hap_alleles = ([], [])
-    for idx, haplo_tuple in enumerate(haplotypes): # Getting the mode value of alleles from clusters
-        for each_read in haplo_tuple:
-            hap_alleles[idx].append(locus_read_allele[each_read][0])
-
-    genotypes = []
-    for alleles_set in hap_alleles: # making the set of final alleles from two clusters
-        genotypes.append(statistics.mode(alleles_set))
-
-    
-    hap_reads = ([],[])
-    for i,al in enumerate(genotypes):
-        hap_reads[i].extend([read_id for read_id in haplotypes[i] if locus_read_allele[read_id][0]==al])
-
-    allele_count = {}
-    for index, allele in enumerate(genotypes):
-        if allele not in allele_count:
-            allele_count[allele] = hap_alleles[index].count(allele)
+        snp_left_boundary = locus.start - cooper.args.snp_dist
+        min_idx = 0
+        for each_spos in cooper.cooper_sorted_snps:
+            if each_spos >= snp_left_boundary:
+                break
+            del cooper.cooper_snp_data[each_spos]
+            min_idx += 1
+        del cooper.cooper_sorted_snps[:min_idx]
+
+    for i, hap_reads in enumerate(locus_data.hap_read_sets):
+        hap_reads = sorted(hap_reads)
+        hap_lengths = locus_data.hap_alen_sets[i]
+        ALT, allele_length, decomp_seq, is_repetitive = alt_sequence(locus_data.read_aseqs, hap_reads, locus.motif_length)
+        lower, upper = (round(x) for x in np.percentile(np.array(hap_lengths), [2.5, 97.5]))
+        if i == 0:
+            locus_data.gt_aseqs        = (ALT, locus_data.gt_aseqs[1])
+            locus_data.gt_alens        = (allele_length, locus_data.gt_alens[1])
+            locus_data.gt_decomp_seqs  = (decomp_seq, locus_data.gt_decomp_seqs[1])
+            locus_data.hap_meth_data   = (calculate_methylation(hap_reads, locus_data.read_methylation, ALT), locus_data.hap_meth_data[1])
+            locus_data.gt_arange       = (f'{lower}-{upper}', locus_data.gt_arange[1])
         else:
-            allele_count[str(allele)] = hap_alleles[index].count(allele)
-
-    vcf_heterozygous_writer(contig, genotypes, locus_start, global_loci_variations, locus_end, allele_count, len(read_indices), global_loci_info, ref, out, chosen_snpQ, phased_read, snp_num, hap_reads)
-    state = True
-    return [state, skip_point]
-    
\ No newline at end of file
+            locus_data.gt_aseqs        = (locus_data.gt_aseqs[0], ALT)
+            locus_data.gt_alens        = (locus_data.gt_alens[0], allele_length)
+            locus_data.gt_decomp_seqs  = (locus_data.gt_decomp_seqs[0], decomp_seq)
+            locus_data.hap_meth_data   = (locus_data.hap_meth_data[0], calculate_methylation(hap_reads, locus_data.read_methylation, ALT))
+            locus_data.gt_arange       = (locus_data.gt_arange[0], f'{lower}-{upper}')
+    write_heterozygous_call(cooper, locus_key)
+
+    return
diff --git a/ATARVA/length_utils.py b/ATARVA/length_utils.py
new file mode 100644
index 0000000..2115019
--- /dev/null
+++ b/ATARVA/length_utils.py
@@ -0,0 +1,452 @@
+import warnings
+from sklearn.cluster import KMeans
+from threadpoolctl import threadpool_limits
+from sklearn.mixture import GaussianMixture
+from scipy.signal import find_peaks
+from hdbscan import HDBSCAN
+
+from ATARVA.vcf_writer import *
+from ATARVA.sub_operation_utils import alt_sequence
+from ATARVA.somatic_utils import *
+
+def _assign_genotype(cooper, locus_key, locus_data,
+                     c1_idx, c2_idx, c1_lengths, c2_lengths,
+                     hap_read_sets, min_cluster_size):
+    """Shared genotype assignment logic for all clustering methods."""
+
+    # ── haploid ───────────────────────────────────────────────────────
+    if cooper.haploid:
+        major_idx   = 0 if len(c1_idx) >= len(c2_idx) else 1
+        major_alens = c1_lengths if major_idx == 0 else c2_lengths
+        major_reads = hap_read_sets[major_idx]
+
+        locus_data.hap_read_sets = (major_reads, [])
+        locus_data.hap_alen_sets = (major_alens, None)
+
+        if len(major_reads) < min_cluster_size:
+            locus_data.skip_code = 1
+            return
+
+        homozygous_call(cooper, locus_key)
+        return
+
+    # ── diploid ───────────────────────────────────────────────────────
+    c1_valid = bool(c1_idx) and len(c1_idx) >= min_cluster_size
+    c2_valid = bool(c2_idx) and len(c2_idx) >= min_cluster_size
+
+    if c1_valid and c2_valid:
+        locus_data.hap_read_sets = hap_read_sets
+        locus_data.hap_alen_sets = (c1_lengths, c2_lengths)
+        heterozygous_call(cooper, locus_key)
+        return
+
+    if c1_valid:
+        locus_data.hap_read_sets = (hap_read_sets[0], hap_read_sets[0])
+        locus_data.hap_alen_sets = (c1_lengths, c1_lengths)
+        homozygous_call(cooper, locus_key)
+        return
+
+    if c2_valid:
+        locus_data.hap_read_sets = (hap_read_sets[1], hap_read_sets[1])
+        locus_data.hap_alen_sets = (c2_lengths, c2_lengths)
+        homozygous_call(cooper, locus_key)
+        return
+
+    locus_data.skip_code = 6
+
+
+def homozygous_call(cooper, locus_key):
+    """
+    genotype a homozygous locus and build the ALT sequence for the haplotype
+    :param cooper:     cooper object
+    :param locus_key:  key for the locus
+    :return:           [bool_state, category]
+    """
+
+    locus        = cooper.cooper_loci_info[locus_key]
+    locus_data   = cooper.cooper_loci_data[locus_key]
+    hap_reads    = locus_data.hap_read_sets[0]
+    hap_lengths  = locus_data.hap_alen_sets[0]
+
+    lower, upper = (round(x) for x in np.percentile(np.array(hap_lengths), [2.5, 97.5]))
+
+    ALT, allele_length, decomposed_seq, is_repetitive = alt_sequence(locus_data.read_aseqs, hap_reads, locus.motif_length)
+    # if not is_repetitive:
+    #     locus_data.skip_code = 6
+    #     return
+
+    locus_data.gt_aseqs        = (ALT, None)
+    locus_data.gt_alens        = (allele_length, None)
+    locus_data.gt_decomp_seqs  = (decomposed_seq, None)
+    locus_data.hap_meth_data   = (calculate_methylation(hap_reads, locus_data.read_methylation, ALT), None)
+    locus_data.gt_arange       = (f'{lower}-{upper}', None)
+
+    write_homozygous_call(cooper, locus_key)
+    return
+
+
+def heterozygous_call(cooper, locus_key):
+    """
+    genotype a heterozygous locus and build the ALT sequences for the haplotypes
+    :param cooper:          cooper object
+    :param locus_key:       key for the locus
+    :return:                [bool_state, category]
+    """
+
+    locus      = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
+    hap_read_sets = locus_data.hap_read_sets
+    hap_alen_sets = locus_data.hap_alen_sets
+
+    for i in range(2):
+        hap_reads = hap_read_sets[i]
+        hap_lengths = hap_alen_sets[i]
+        ALT, allele_length, decomp_seq, is_repetitive = alt_sequence(locus_data.read_aseqs, hap_reads, locus.motif_length)
+        lower, upper = (round(x) for x in np.percentile(np.array(hap_lengths), [2.5, 97.5]))
+        if i == 0:
+            locus_data.gt_aseqs         = (ALT, locus_data.gt_aseqs[1])
+            locus_data.gt_alens         = (allele_length, locus_data.gt_alens[1])
+            locus_data.gt_decomp_seqs   = (decomp_seq, locus_data.gt_decomp_seqs[1])
+            locus_data.hap_meth_data    = (calculate_methylation(hap_reads, locus_data.read_methylation, ALT), locus_data.hap_meth_data[1])
+            locus_data.gt_arange        = (f'{lower}-{upper}', locus_data.gt_arange[1])
+        else:
+            locus_data.gt_aseqs         = (locus_data.gt_aseqs[0], ALT)
+            locus_data.gt_alens         = (locus_data.gt_alens[0], allele_length)
+            locus_data.gt_decomp_seqs   = (locus_data.gt_decomp_seqs[0], decomp_seq)
+            locus_data.hap_meth_data    = (locus_data.hap_meth_data[0], calculate_methylation(hap_reads, locus_data.read_methylation, ALT))
+            locus_data.gt_arange        = (locus_data.gt_arange[0], f'{lower}-{upper}')
+
+    write_heterozygous_call(cooper, locus_key)
+
+    return [True, 10]
+
+
+def compute_cluster_cutoff(minor_cluster, major_cluster):
+    """
+    compute minimum read cutoff for the minor cluster based on
+    whether it overlaps with the major cluster's allele range.
+
+    :param minor_cluster: smaller allele length cluster
+    :param major_cluster: larger allele length cluster
+    :return:              minimum read count cutoff
+    """
+    max_major    = max(major_cluster)
+    tolerance    = max(max_major * 0.1, 10)        # 10% of max or at least 10bp
+    lower_bound  = min(major_cluster) - tolerance
+    upper_bound  = max_major          + tolerance
+
+    # if minor cluster overlaps with major - no cutoff needed
+    overlaps = any(lower_bound <= alen <= upper_bound for alen in minor_cluster)
+    if overlaps: return 0.15 * (len(major_cluster) + len(minor_cluster)) # 15% of total reads in both clusters
+
+    # min 3% of major cluster size, at least 2 reads
+    ratio_cutoff = int(max(0.03, len(minor_cluster) / len(major_cluster)) * len(major_cluster))
+    return max(2, ratio_cutoff)
+
+
+def length_genotyper(cooper, locus_key):
+    """
+    genotype a locus by clustering allele lengths using KMeans.
+
+    :param cooper:     cooper object
+    :param locus_key:  key for the locus
+    :return:           [bool_state, category]
+    """
+
+    MIN_READS        = 3
+    MIN_CLUSTER_FRAC = 0.15
+    WINDOW_FRAC      = 0.1
+
+    locus_data = cooper.cooper_loci_data[locus_key]
+    read_alens = locus_data.read_alens
+
+    read_indices    = sorted(locus_data.reads)
+    unique_alens    = set(locus_data.allele_lengths)
+    singleton_alens = {alen for alen, count in locus_data.halen_frequency.items() if count == 1}
+
+    # --- pre-compute 10% windows for each unique allele ---
+    windows = { i: (round(i * (1 - WINDOW_FRAC)), round(i * (1 + WINDOW_FRAC))) for i in unique_alens }
+
+    # --- filter singleton alleles not near any other allele ---
+    main_read_ids  = []
+    filtered_alens = []
+
+    for read_index in read_indices:
+        alen = read_alens[read_index][0]
+        if alen in singleton_alens:
+            near_other = any(lo <= alen <= hi for i, (lo, hi) in windows.items() if i != alen)
+            # NOTE: filters out singleton alleles which are not within 10% of any other allele,
+            #       these outlier can potentially create spurious clusters
+            if not near_other: continue
+        main_read_ids.append(read_index)
+        filtered_alens.append(alen)
+
+    if len(filtered_alens) < MIN_READS:
+        locus_data.skip_code = 0
+        return
+
+    # --- KMeans clustering ---
+    alen_array = np.array(filtered_alens).reshape(-1, 1)
+    with threadpool_limits(limits=1):
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=UserWarning)
+            kmeans = KMeans(n_clusters=2, init='k-means++', n_init=5, random_state=0).fit(alen_array)
+
+    # --- split into clusters in single pass ---
+    c1_idx, c2_idx = [], []
+    for i, label in enumerate(kmeans.labels_):
+        (c1_idx if label == 0 else c2_idx).append(i)
+
+    c1_lengths    = [filtered_alens[i] for i in c1_idx]
+    c2_lengths    = [filtered_alens[i] for i in c2_idx]
+    hap_read_sets = ([main_read_ids[i] for i in c1_idx], [main_read_ids[i] for i in c2_idx])
+
+    locus_data.gt_depth = len(filtered_alens)
+    # --- compute cluster cutoff ---
+    min_cluster_size = MIN_CLUSTER_FRAC * len(filtered_alens)
+
+    if c1_idx and c2_idx:
+        if len(c1_idx) < min_cluster_size <= len(c2_idx):
+            min_cluster_size = compute_cluster_cutoff(c1_lengths, c2_lengths)
+        elif len(c2_idx) < min_cluster_size <= len(c1_idx):
+            min_cluster_size = compute_cluster_cutoff(c2_lengths, c1_lengths)
+
+    _assign_genotype(cooper, locus_key, locus_data,
+                     c1_idx, c2_idx, c1_lengths, c2_lengths,
+                     hap_read_sets, min_cluster_size)
+
+
+def length_genotyper_gmm(cooper, locus_key):
+    """Genotype using Gaussian Mixture Model."""
+
+    MIN_READS        = 3
+    MIN_CLUSTER_FRAC = 0.15
+    WINDOW_FRAC      = 0.1
+
+    locus_data = cooper.cooper_loci_data[locus_key]
+    read_alens = locus_data.read_alens
+
+    read_indices    = sorted(locus_data.reads)
+    unique_alens    = set(locus_data.allele_lengths)
+    singleton_alens = {alen for alen, count in locus_data.halen_frequency.items() if count == 1}
+    windows         = {i: (round(i * (1 - WINDOW_FRAC)), round(i * (1 + WINDOW_FRAC)))
+                       for i in unique_alens}
+
+    main_read_ids  = []
+    filtered_alens = []
+    for read_index in read_indices:
+        alen = read_alens[read_index][0]
+        if alen in singleton_alens:
+            if not any(lo <= alen <= hi for i, (lo, hi) in windows.items() if i != alen):
+                continue
+        main_read_ids.append(read_index)
+        filtered_alens.append(alen)
+
+    if len(filtered_alens) < MIN_READS:
+        locus_data.skip_code = 0
+        return
+
+    alen_array = np.array(filtered_alens).reshape(-1, 1)
+
+    # ── GMM fitting ───────────────────────────────────────────────────
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=UserWarning)
+        gmm    = GaussianMixture(
+            n_components    = 2,
+            covariance_type = 'full',
+            random_state    = 0,
+            n_init          = 5
+        ).fit(alen_array)
+
+    labels = gmm.predict(alen_array)
+    probs  = gmm.predict_proba(alen_array)   # confidence per assignment
+
+    # ── split clusters ────────────────────────────────────────────────
+    c1_idx = [i for i, l in enumerate(labels) if l == 0]
+    c2_idx = [i for i, l in enumerate(labels) if l == 1]
+
+    # filter low confidence assignments
+    MIN_PROB      = 0.7
+    c1_idx = [i for i in c1_idx if probs[i][0] >= MIN_PROB]
+    c2_idx = [i for i in c2_idx if probs[i][1] >= MIN_PROB]
+
+    c1_lengths    = [filtered_alens[i] for i in c1_idx]
+    c2_lengths    = [filtered_alens[i] for i in c2_idx]
+    hap_read_sets = (
+        [main_read_ids[i] for i in c1_idx],
+        [main_read_ids[i] for i in c2_idx]
+    )
+
+    locus_data.gt_depth      = len(filtered_alens)
+    min_cluster_size         = MIN_CLUSTER_FRAC * len(filtered_alens)
+
+    if c1_idx and c2_idx:
+        if len(c1_idx) < min_cluster_size <= len(c2_idx):
+            min_cluster_size = compute_cluster_cutoff(c1_lengths, c2_lengths)
+        elif len(c2_idx) < min_cluster_size <= len(c1_idx):
+            min_cluster_size = compute_cluster_cutoff(c2_lengths, c1_lengths)
+    
+    _assign_genotype(cooper, locus_key, locus_data,
+                     c1_idx, c2_idx, c1_lengths, c2_lengths,
+                     hap_read_sets, min_cluster_size)
+
+
+
+def length_genotyper_hdbscan(cooper, locus_key):
+    """Genotype using HDBSCAN — auto cluster count, outlier aware."""
+
+    MIN_READS        = 3
+    MIN_CLUSTER_FRAC = 0.15
+    WINDOW_FRAC      = 0.1
+
+    locus_data = cooper.cooper_loci_data[locus_key]
+    read_alens = locus_data.read_alens
+
+    read_indices    = sorted(locus_data.reads)
+    unique_alens    = set(locus_data.allele_lengths)
+    singleton_alens = {alen for alen, count in locus_data.halen_frequency.items() if count == 1}
+    windows         = {i: (round(i * (1 - WINDOW_FRAC)), round(i * (1 + WINDOW_FRAC)))
+                       for i in unique_alens}
+
+    main_read_ids  = []
+    filtered_alens = []
+    for read_index in read_indices:
+        alen = read_alens[read_index][0]
+        if alen in singleton_alens:
+            if not any(lo <= alen <= hi for i, (lo, hi) in windows.items() if i != alen):
+                continue
+        main_read_ids.append(read_index)
+        filtered_alens.append(alen)
+
+    if len(filtered_alens) < MIN_READS:
+        locus_data.skip_code = 0
+        return
+
+    alen_array = np.array(filtered_alens).reshape(-1, 1)
+
+    # ── HDBSCAN clustering ────────────────────────────────────────────
+    clusterer = HDBSCAN(
+        min_cluster_size     = max(MIN_READS, int(MIN_CLUSTER_FRAC * len(filtered_alens))),
+        allow_single_cluster = True    # ✅ handles homozygous
+    ).fit(alen_array)
+
+    labels     = clusterer.labels_
+    unique_labels = set(labels) - {-1}   # -1 = noise/outlier
+
+    if not unique_labels:
+        locus_data.skip_code = 0
+        return
+
+    # ── build clusters — ignore noise reads ──────────────────────────
+    clusters = {
+        label: [i for i, l in enumerate(labels) if l == label]
+        for label in unique_labels
+    }
+
+    # ── take two largest clusters ─────────────────────────────────────
+    top2      = sorted(clusters, key=lambda l: len(clusters[l]), reverse=True)[:2]
+    c1_idx    = clusters[top2[0]]
+    c2_idx    = clusters[top2[1]] if len(top2) > 1 else []
+
+    c1_lengths    = [filtered_alens[i] for i in c1_idx]
+    c2_lengths    = [filtered_alens[i] for i in c2_idx]
+    hap_read_sets = (
+        [main_read_ids[i] for i in c1_idx],
+        [main_read_ids[i] for i in c2_idx]
+    )
+
+    locus_data.gt_depth  = len(filtered_alens)
+    min_cluster_size     = MIN_CLUSTER_FRAC * len(filtered_alens)
+
+    if c1_idx and c2_idx:
+        if len(c1_idx) < min_cluster_size <= len(c2_idx):
+            min_cluster_size = compute_cluster_cutoff(c1_lengths, c2_lengths)
+        elif len(c2_idx) < min_cluster_size <= len(c1_idx):
+            min_cluster_size = compute_cluster_cutoff(c2_lengths, c1_lengths)
+
+    _assign_genotype(cooper, locus_key, locus_data,
+                     c1_idx, c2_idx, c1_lengths, c2_lengths,
+                     hap_read_sets, min_cluster_size)
+
+
+
+def length_genotyper_histogram(cooper, locus_key):
+    """Genotype using histogram peak detection — fastest, no sklearn."""
+
+    MIN_READS        = 3
+    MIN_CLUSTER_FRAC = 0.15
+    WINDOW_FRAC      = 0.1
+    BIN_WIDTH        = 5
+
+    locus_data = cooper.cooper_loci_data[locus_key]
+    read_alens = locus_data.read_alens
+
+    read_indices    = sorted(locus_data.reads)
+    unique_alens    = set(locus_data.allele_lengths)
+    singleton_alens = {alen for alen, count in locus_data.halen_frequency.items() if count == 1}
+    windows         = {i: (round(i * (1 - WINDOW_FRAC)), round(i * (1 + WINDOW_FRAC)))
+                       for i in unique_alens}
+
+    main_read_ids  = []
+    filtered_alens = []
+    for read_index in read_indices:
+        alen = read_alens[read_index][0]
+        if alen in singleton_alens:
+            if not any(lo <= alen <= hi for i, (lo, hi) in windows.items() if i != alen):
+                continue
+        main_read_ids.append(read_index)
+        filtered_alens.append(alen)
+
+    if len(filtered_alens) < MIN_READS:
+        locus_data.skip_code = 0
+        return
+
+    arr = np.array(filtered_alens)
+
+    # ── histogram peak detection ──────────────────────────────────────
+    bins         = np.arange(arr.min(), arr.max() + BIN_WIDTH, BIN_WIDTH)
+    counts, edges = np.histogram(arr, bins=bins)
+    min_count    = max(2, round(MIN_CLUSTER_FRAC * len(filtered_alens)))
+    peaks, _     = find_peaks(counts, height=min_count, distance=2)
+
+    if len(peaks) == 0:
+        locus_data.skip_code = 0
+        return
+
+    # ── assign reads to nearest peak ─────────────────────────────────
+    peak_centres = [(edges[p] + edges[p + 1]) / 2 for p in peaks]
+    top2_centres = sorted(peak_centres,
+                          key=lambda c: counts[np.searchsorted(edges, c) - 1],
+                          reverse=True)[:2]
+
+    def nearest_peak(alen):
+        return min(range(len(top2_centres)),
+                   key=lambda i: abs(alen - top2_centres[i]))
+
+    c1_idx = [i for i, a in enumerate(filtered_alens) if nearest_peak(a) == 0]
+    c2_idx = [i for i, a in enumerate(filtered_alens) if nearest_peak(a) == 1]
+
+    c1_lengths    = [filtered_alens[i] for i in c1_idx]
+    c2_lengths    = [filtered_alens[i] for i in c2_idx]
+    hap_read_sets = (
+        [main_read_ids[i] for i in c1_idx],
+        [main_read_ids[i] for i in c2_idx]
+    )
+
+    locus_data.gt_depth  = len(filtered_alens)
+    min_cluster_size     = MIN_CLUSTER_FRAC * len(filtered_alens)
+
+    if c1_idx and c2_idx:
+        if len(c1_idx) < min_cluster_size <= len(c2_idx):
+            min_cluster_size = compute_cluster_cutoff(c1_lengths, c2_lengths)
+        elif len(c2_idx) < min_cluster_size <= len(c1_idx):
+            min_cluster_size = compute_cluster_cutoff(c2_lengths, c1_lengths)
+
+    # if locus_key == 'chr1:30651346-30651962':
+    #     print(f'Histogram clusters for {locus_key}:')
+    #     print(f'  Cluster 1: {sorted([int(x) for x in c1_lengths])}')
+    #     print(f'  Cluster 2: {sorted([int(x) for x in c2_lengths])}')
+
+    _assign_genotype(cooper, locus_key, locus_data,
+                     c1_idx, c2_idx, c1_lengths, c2_lengths,
+                     hap_read_sets, min_cluster_size)
diff --git a/ATARVA/libssw.so b/ATARVA/libssw.so
new file mode 100644
index 0000000..a19d79e
Binary files /dev/null and b/ATARVA/libssw.so differ
diff --git a/ATARVA/locus_utils.py b/ATARVA/locus_utils.py
index bd1975d..954c40c 100644
--- a/ATARVA/locus_utils.py
+++ b/ATARVA/locus_utils.py
@@ -1,189 +1,304 @@
-from ATARVA.realignment_utils import *
-import sys
+import bisect
 
-def count_alleles(locus_key, read_indices, global_loci_variations, allele_counter, hallele_counter):
+from ATARVA.realignment import *
+from ATARVA.vcf_writer  import write_fail_call
+
+
+def break_locuskey(locus_key):
+    """
+    break the locus key into chrom, start and end coordinates
+
+    :param locus_key: string in the format chrom:start-end
+    :return: chrom, start and end coordinates
+    """
+    chrom = locus_key[:locus_key.index(':')]
+    start = int(locus_key[(locus_key.index(':') + 1) : locus_key.index('-')])
+    end   = int(locus_key[(locus_key.index('-') + 1) :])
+    return chrom, start, end
+
+
+def count_alleles(cooper, locus_key):
     """
-    Counts the read distribution for each allele length
+    frequency of each allele length across all reads for a locus
+
+    :param cooper: Cooper object
+    :param locus_key: string in the format chrom:start-end
+    :return: None (updates the cooper.cooper_loci_data[locus_key].alen_frequency and cooper.cooper_loci_data[locus_key].halen_frequency in place)
     """
-    for rindex in read_indices:
-        halen, alen = global_loci_variations[locus_key]['read_allele'][rindex]
 
-        try: allele_counter[alen] += 1
-        except KeyError: allele_counter[alen] = 1
+    locus_data = cooper.cooper_loci_data[locus_key]
+    read_indices = locus_data.reads
+    for read_index in read_indices:
+        halen, alen = locus_data.read_alens[read_index]
+        locus_data.allele_lengths.append(halen)
 
-        try: hallele_counter[halen] += 1
-        except KeyError: hallele_counter[halen] = 1
+        try: locus_data.alen_frequency[alen] += 1
+        except KeyError: locus_data.alen_frequency[alen] = 1
 
+        try: locus_data.halen_frequency[halen] += 1
+        except KeyError: locus_data.halen_frequency[halen] = 1
 
-def record_snps(read_indices, old_reads, new_reads, global_read_variations, global_snp_positions, sorted_global_snp_list):
 
-    for rindex in read_indices:
-        if rindex not in new_reads: continue
-        
-        rstart = global_read_variations[rindex]['s']
-        rend   = global_read_variations[rindex]['e']
-        snps   = global_read_variations[rindex]['snps']
-        dels   = global_read_variations[rindex]['dels']
-        
-        for pos in sorted_global_snp_list:
-        
-            if pos < rstart: continue
-            if pos > rend: break
-            if pos not in snps and pos not in dels:
-                if 'r' in global_snp_positions[pos]: global_snp_positions[pos]['r'].add(rindex)
-                else: global_snp_positions[pos]['r'] = {rindex}
-                global_snp_positions[pos]['cov'] += 1
+def record_ref_snps(cooper, new_reads, locus_start, locus_end):
+    """
+    update ref allele and coverage for all reads with no SNPs
 
+    :param cooper: ATaRVa object
+    :param read_indices: list of read indices covering the locus
+    :param new_reads: set of read indices which are new to the locus
+    :param locus_start: start coordinate of the locus
+    :param locus_end: end coordinate of the locus
+    :param snp_dist: distance from the locus to consider for recording SNPs
+    :return: None (updates the cooper.cooper_snp_data in place)
+    """
+
+    snp_dist = cooper.args.snp_dist
+    snp_start = locus_start - snp_dist
+    snp_end   = locus_end + snp_dist
+
+    for read_index in new_reads:
+
+        read = cooper.cooper_read_data[read_index]
+
+        for pos in cooper.cooper_sorted_snps:
+            # if snp not in range skip
+            if not (snp_start <= pos <= snp_end): continue
+
+            if pos < read.start: continue
+            if pos > read.end: break
+
+            # if a position has not ALT SNP and is not deleted in the read record it as reference
+            if (pos not in read.snps) and (bisect.bisect(read.dels, pos) % 2 == 0) and (pos not in read.no_snps):
+                cooper.cooper_snp_data[pos].ref.add(read_index)
+                cooper.cooper_snp_data[pos].cov += 1
+
+
+def inrepeat_ins(near_by_loci, ins_rpos, sorted_ins_rpos):
+    """
+    if flank repeat falls in another repeat
 
-def inrepeat_ins(near_by_loci, ins_rpos, sorted_global_ins_rpos_set):
+    :param near_by_loci: list of nearby loci coordinates
+    :param ins_rpos: reference position of the insertion
+    :param sorted_ins_rpos: set of reference positions of insertions across all loci
+    """
     for locus in near_by_loci:
         if locus[0] <= ins_rpos <= locus[1]:
-            sorted_global_ins_rpos_set.add(ins_rpos)
+            sorted_ins_rpos.add(ins_rpos)
             return 1
     return 0
 
 
+def subset_reads(cooper, locus_data):
+    """
+    subsets reads for loci with high coverage based on read quality.
+
+    :param cooper:         cooper object containing read data and args
+    :param read_indices:   list of read indices covering the locus
+    :param read_haplotags: list of haplotype tags for the reads
+    :return:               subsetted read indices and corresponding haplotype tags
+    """
+    read_indices   = locus_data.reads
+    read_haplotags = locus_data.read_haplotags
+
+    locus_data.raw_reads     = read_indices
+    locus_data.raw_depth     = len(read_indices)
+
+    # sort read indices by quality in one step — no intermediate dict
+    sorted_reads = sorted(
+        read_indices,
+        key     = lambda i: cooper.cooper_read_data[i].mean_qual,
+        reverse = True
+    )
+
+    # subset top max_reads
+    top_reads = set(sorted_reads[:cooper.args.max_reads])
+
+    # filter haplotags and indices in single pass
+    # read_indices, read_haplotags = zip(
+    #     *[(i, ht) for i, ht in zip(read_indices, read_haplotags) if i in top_reads]
+    # ) if top_reads else ([], [])
+
+    locus_data.reads          = list(top_reads)
+    locus_data.depth          = len(read_indices)
+
+
+def process_flank_insertions(flank_insertions, ref_allele, ref_length, query, locus, locus_neighbors, insert_positions, is_left):
+    """
+    process insertions in flanks and adjusts locus boundaries if needed
+
+    :param flank_insertions: list of tuples with insertion reference position and query start and end positions
+    :param ref_allele: reference allele sequence for the locus
+    :param ref_length: reference allele length for the locus
+    :param query: read sequence for the locus
+    :param locus: locus object containing locus information
+    :param locus_neighbors: list of neighboring loci coordinates
+    :param insert_positions: set of reference positions of insertions across all loci
+    :param is_left: boolean value indicating if the flank is left or right
+    :return: adjusted query start or end position, set of pending insertions, counts of larger, partial and complete insertions
+    """
+
+    ILR = PI = CI = 0
+    pending = set()
+    adj_pos = None
+
+    ref_75 = round(0.75 * ref_length)
+
+    for fid, (ins_rpos, ins_qs, ins_qe) in enumerate(flank_insertions):
+        ins_len = ins_qe - ins_qs
+        if ins_len < locus.motif_length and ins_len < 10: continue
+        if ins_rpos in insert_positions:                  continue
+        if inrepeat_ins(locus_neighbors, ins_rpos, insert_positions): continue
+
+        insert          = query[ins_qs:ins_qe]
+        alignment, coords = stripSW(Inputs(ref_allele, insert), True)
+        align_len       = len(alignment)
+        matches         = alignment.count('|')
+        min_len         = min(ins_len, ref_length)
+
+        if align_len <= round(0.2 * min_len): continue
+
+        if align_len >= ref_75 and matches >= round(0.75 * align_len):
+            ILR  += 1
+            adj_pos = ins_qs if is_left else ins_qe
+            pending.update(ins[0] for ins in flank_insertions[fid:])
+            break
+
+        elif (matches   >= round(0.75 * align_len) and
+              align_len >= round(0.45 * ins_len)):
+            PI += 1 if align_len <= 0.5 * ins_len else 0
+            CI += 1 if align_len >  0.5 * ins_len else 0
+            if is_left and coords[1] >= round(0.7 * ins_len):
+                adj_pos = ins_qs + coords[0]
+                pending.update(ins[0] for ins in flank_insertions[fid:])
+                break
+            elif not is_left and coords[0] <= round(0.3 * ins_len):
+                adj_pos = ins_qs + coords[1]
+                pending.update(ins[0] for ins in flank_insertions[fid:])
+                break
+
+    return adj_pos, pending, ILR, PI, CI
+
+
+def assign_hap_category(locus_data):
+    """
+    assign category for the locus based on haplotype status and allele distribution
+
+    :param locus_data: LocusVariation object containing locus-specific data
+    :return: None (updates the locus_data.hap_category in place)
+    """
+
+    if locus_data.is_genotyped and (list(locus_data.read_haplotags.values()).count(None) / locus_data.depth) <= 0.15:
+        locus_data.hap_category = 3 # phased based on haplotag
+        return
+
+    read_aseqs = [aseq[0] for aseq in locus_data.read_aseqs.values()]
+    locus_data.phase_mode = None
+    seq_counter = {}
+    for aseq in read_aseqs:
+        try: seq_counter[len(aseq)] += 1
+        except KeyError: seq_counter[len(aseq)] = 1
+    filtered_seqs = {seq: count for seq, count in seq_counter.items() if count > 1}
+    max_freq = max(filtered_seqs.values()) if filtered_seqs else 0
+    if len(filtered_seqs) == 1 or max_freq / locus_data.depth >= 0.75:
+        locus_data.hap_category    = 1 # homozygous
+        return
+
+    locus_data.hap_category = 2 # ambiguous
+
+
+def process_locus(cooper, locus_key):
+    """
+    process the reads for a locus
+
+    :param cooper:        cooper object containing read data and args
+    :param locus_key:     string in the format chrom:start-end
+    :return: None (updates the cooper.cooper_loci_data[locus_key] in place)
+    """
+
+    locus      = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
+
+    ref_allele = cooper.ref.fetch(cooper.chrom, locus.start, locus.end)
+    ref_length = locus.length
+    locus_data.neighbors.remove((locus.start, locus.end))
+
+    read_indices      = locus_data.reads
+
+    pending_insertions  = set()
+    ILR = PI = CI       = 0
+
+    # --- coverage check ---
+    if locus_data.depth < cooper.args.min_reads:
+        cooper.prev_reads    = set(read_indices)
+        cooper.prev_reads.clear()
+        locus_data.skip_code = 0
+        return
+
+    if locus_data.depth > cooper.args.max_reads:
+        subset_reads(cooper, locus_data)
 
-def process_locus(locus_key, global_loci_variations, global_read_variations, global_snp_positions, prev_reads, sorted_global_snp_list, maxR, minR, global_loci_info, near_by_loci, sorted_global_ins_rpos_set, Chrom, locus_start, locus_end, ref, log_bool, logger):
-
-
-    ref_seq = ref.fetch(Chrom, locus_start, locus_end)
-    ref_len = len(ref_seq)
-    locus_tuple = (locus_start, locus_end)
-    near_by_loci.remove(locus_tuple)
-    
-    homozygous = False
-    ambiguous = False
-    homozygous_allele = 0
-    reads_of_homozygous = []
-    read_indices = global_loci_variations[locus_key]['reads']   # the read indices which cover the locus
-    total_reads = len(read_indices)                             # total number of reads
-    max_limit=0
-    motif = global_loci_info[locus_key][3]
-    period = int(float(global_loci_info[locus_key][4]))
-    new_ins_rpos_current_loci = set()
-
-    # remove if the locus has poor coverage
-    if total_reads < minR:
-        # coverage of the locus is low
-        prev_reads = set(read_indices)
-        return [prev_reads, homozygous, ambiguous, homozygous_allele, reads_of_homozygous, {}, 0, max_limit]
-    elif total_reads > maxR:
-        # coverage of the locus is high
-        read_indices = read_indices[:maxR]
-        max_limit=1
-    
     current_reads = set(read_indices)
-    old_reads = prev_reads - current_reads
-    new_reads = current_reads - prev_reads
-
-    locus_read_allele = global_loci_variations[locus_key]['read_allele'] # extracting allele info from global_loci_variation
-    locus_read_seq = global_loci_variations[locus_key]['read_sequence']
-    ILR=0;PI=0;CI=0;
-    for each_read in read_indices:
-
-        query,rep_range,ins_left,ins_right, left_rpos, right_rpos = locus_read_seq[each_read] # fetching repeat seq with flanks, correct start end position and insertion coordinates
-
-        new_start,new_end = rep_range # new coordinates same as correct corrdinates
-        if new_end-new_start != locus_read_allele[each_read][0]:
-            print(f'Calculated allele length is not same at locus {locus_key} where alen is {locus_read_allele[each_read][0]} and ranges is {rep_range} and end-start = {new_end-new_start}')
-            sys.exit()
-        
-        
-        sorted_left = sorted(ins_left,key = lambda x: x[0]) # sorting the coordinates so if the 1st insertion is itself a repeat, fetch seq from that position; no need for checking the successive ins (only for all left ins)
-        sorted_right = sorted(ins_right,key = lambda x: x[0], reverse=True) # for right ins, there are no breaks
-        sorted_left_rpos = sorted(left_rpos)
-        sorted_right_rpos = sorted(right_rpos, reverse=True)
-
-
-        for lid,each_tuple in enumerate(sorted_left):# checking the insertion on left, whether its a repeats or not
-            ins_len = each_tuple[1]-each_tuple[0]
-            
-            if ins_len < period:
-                if ins_len>=10: pass
-                else: continue
-            ins_rpos = sorted_left_rpos[lid]
-            if ins_rpos in sorted_global_ins_rpos_set: continue
-            elif inrepeat_ins(near_by_loci, ins_rpos, sorted_global_ins_rpos_set): continue
-            else:
-                test_query = query[each_tuple[0]: each_tuple[1]]
-                align, pos = stripSW(Inputs(ref_seq, test_query))
-                que_len = len(test_query)
-                align_len = len(align)
-
-                if align_len<=round(0.2*min([que_len,ref_len])):
-                    continue
-                elif (align_len >= round(0.75*ref_len)) and (align.count('|') >= round(0.75*align_len)): # when insertion is larger then the ref seq
-                    ILR+=1
-                    new_start = each_tuple[0] #+ pos[0]
-                    for ins in sorted_left_rpos[lid:]:
-                        new_ins_rpos_current_loci.add(ins)
-                    break
-                elif (align.count('|') >= round(0.75*align_len)) and (pos[1]>=round(0.7*que_len)) and (align_len>=round(0.45*que_len)):
-                    if align_len<=0.5*que_len: PI+=1
-                    else: CI+=1
-                    # print('either CI or PI')
-                    new_start = each_tuple[0] + pos[0]
-                    for ins in sorted_left_rpos[lid:]:
-                        new_ins_rpos_current_loci.add(ins)
-                    break
-
-        for rid,each_tuple in enumerate(sorted_right):
-            ins_len = each_tuple[1]-each_tuple[0]
-            if ins_len < period:
-                if ins_len>=10: pass
-                else: continue
-            ins_rpos = sorted_right_rpos[rid]
-            if ins_rpos in sorted_global_ins_rpos_set: continue
-            elif inrepeat_ins(near_by_loci, ins_rpos, sorted_global_ins_rpos_set): continue
-            else:
-                test_query = query[each_tuple[0]: each_tuple[1]]
-                align, pos = stripSW(Inputs(ref_seq, test_query))
-                que_len = len(test_query)
-                align_len = len(align)
-                if align_len<=round(0.2*min([que_len,ref_len])):
-                    continue
-                elif (align_len >= round(0.75*ref_len)) and (align.count('|') >= round(0.75*align_len)): # when insertion is larger then the ref seq
-                    ILR+=1
-                    new_end = each_tuple[1] #each_tuple[0] + pos[1]
-                    for ins in sorted_right_rpos[rid:]:
-                        new_ins_rpos_current_loci.add(ins)
-                    break
-                elif (align.count('|') >= round(0.75*align_len)) and (pos[0]<=round(0.3*que_len)) and (align_len>=round(0.45*que_len)):
-                    if align_len<=0.5*que_len: PI+=1
-                    else: CI+=1
-                    new_end = each_tuple[0] + pos[1]
-                    for ins in sorted_right_rpos[rid:]:
-                        new_ins_rpos_current_loci.add(ins)
-                    break
-                    
-
-
-        locus_read_seq[each_read][0] = query[new_start:new_end] # over-writing the query seq with modified seq with/without ins
-        locus_read_allele[each_read][0] = new_end-new_start # over-writing the allele length after modification
-
-    if log_bool: logger.debug(f"{locus_key};Larger_ins={ILR};Partial_ins={PI};Complete_ins={CI}")
-    sorted_global_ins_rpos_set |= new_ins_rpos_current_loci
-    # recording the counts of each allele length across all reads
-    allele_counter = {};  hallele_counter = {}
-    count_alleles(locus_key, read_indices, global_loci_variations, allele_counter, hallele_counter)
-
-    
-    if len(hallele_counter) == 1:
-        homozygous = True
-        homozygous_allele = list(hallele_counter.keys())[0]
-        reads_of_homozygous = read_indices.copy()
-    
-    else:
-        filtered_alleles = list(filter(lambda x: hallele_counter[x] > 1, hallele_counter.keys()))
-        if len(filtered_alleles) == 1 and hallele_counter[filtered_alleles[0]]/total_reads >= 0.75:
-            homozygous = True
-            homozygous_allele = filtered_alleles[0]
-            reads_of_homozygous = [rindex for rindex in global_loci_variations[locus_key]['read_allele'] if homozygous_allele == global_loci_variations[locus_key]['read_allele'][rindex][0]]
-        else:
-            ambiguous = True
-            
-    record_snps(read_indices, old_reads, new_reads, global_read_variations, global_snp_positions, sorted_global_snp_list)
-    
-    prev_reads = current_reads.copy()
-    return [prev_reads, homozygous, ambiguous, homozygous_allele, reads_of_homozygous, hallele_counter, 10, max_limit]
\ No newline at end of file
+    new_reads     = current_reads - cooper.prev_reads
+
+    # --- methylation thresholds ---
+    upper_bound = cooper.args.meth_prob
+    lower_bound = 1 - upper_bound
+
+    # --- per read processing ---
+    for read_index in read_indices:
+        read = cooper.cooper_read_data[read_index]
+        query, relative_qrange, left_ins, right_ins, fqs, fqe = locus_data.read_aseqs[read_index]
+        adj_qs, adj_qe = relative_qrange
+
+        left_ins.sort(key=lambda x: x[0])
+        right_ins.sort(key=lambda x: x[0], reverse=True)
+
+        # process flanks
+        new_qs, pend_l, ilr, pi, ci    = process_flank_insertions(left_ins,  ref_allele, ref_length, query, locus,
+                                                                  locus_data.neighbors, cooper.cooper_insert_positions, is_left=True)
+        new_qe, pend_r, ilr2, pi2, ci2 = process_flank_insertions(right_ins, ref_allele, ref_length, query, locus,
+                                                                  locus_data.neighbors, cooper.cooper_insert_positions, is_left=False)
+
+        if new_qs is not None: adj_qs = new_qs
+        if new_qe is not None: adj_qe = new_qe
+
+        ILR += ilr + ilr2
+        PI  += pi  + pi2
+        CI  += ci  + ci2
+        pending_insertions |= pend_l | pend_r
+
+        locus_data.read_aseqs[read_index][0]   = query[adj_qs:adj_qe]
+        locus_data.read_alens[read_index][0]   = adj_qe - adj_qs
+
+        # methylation
+        subseq_len     = fqe - fqs
+        adj_fqs        = fqs + adj_qs
+        adj_fqe        = fqe - (subseq_len - adj_qe)
+
+        locus_data.read_methylation[read_index] = read.process_methylation_info(adj_fqs, adj_fqe, lower_bound, upper_bound)
+
+    if cooper.args.debug_mode:
+        cooper.logger.debug(f"{locus_key};Larger_ins={ILR};Partial_ins={PI};Complete_ins={CI}")
+
+    cooper.cooper_insert_positions |= pending_insertions
+    count_alleles(cooper, locus_key) # updates frequency of allele lengths in cooper.cooper_loci_data[locus_key]
+
+    record_ref_snps(cooper, new_reads, locus.start, locus.end)
+
+    if cooper.args.haplotag:
+        hap1, hap2 = [], []
+        for read_idx in read_indices:
+            tag = locus_data.read_haplotags[read_idx]
+            if tag == 1: hap1.append(read_idx)
+            if tag == 2: hap2.append(read_idx)
+        locus_data.hap_read_sets        = (hap1, hap2)
+        locus_data.hap_alen_sets = ([locus_data.read_alens[ridx][0] for ridx in hap1], [locus_data.read_alens[ridx][0] for ridx in hap2])
+        # haplotyped successfully if there are reads in both haplogroups
+        locus_data.is_phased  = all(locus_data.hap_read_sets)
+        locus_data.phase_mode = 'haplotag' if locus_data.is_genotyped else None
+
+    assign_hap_category(locus_data)
+
+    cooper.prev_reads.clear()
+    # cooper.prev_reads.update(current_reads)
+    locus_data.skip_code = 10
diff --git a/ATARVA/md_utils.py b/ATARVA/md_utils.py
index 0f17b39..eda9cdc 100644
--- a/ATARVA/md_utils.py
+++ b/ATARVA/md_utils.py
@@ -1,55 +1,98 @@
-import bisect
+from sortedcontainers import SortedList
 
-def update_global_snpPos(ref_start, pos, global_read_variations, global_snp_positions, read_index, read_sequence, read_quality, sorted_global_snp_list, insertion_point, qpos):
+from ATARVA.structures import SNP
 
-    rpos = ref_start+pos
-    for ins in insertion_point:
-        if ins<rpos:
-            qpos+=insertion_point[ins]
-        elif ins>rpos: break
 
-    Q_value = read_quality[qpos]
-    sub_char = read_sequence[qpos]
-    global_read_variations[read_index]['snps'].add(rpos)
-    if rpos not in global_snp_positions:
-        global_snp_positions[rpos] = { 'cov': 1, sub_char: {read_index}, 'Qval': {read_index:Q_value} }
-        bisect.insort(sorted_global_snp_list, rpos)
-    else:
-        global_snp_positions[rpos]['cov'] += 1
-        global_snp_positions[rpos]['Qval'][read_index] = Q_value
-        if sub_char in global_snp_positions[rpos]: 
-            global_snp_positions[rpos][sub_char].add(read_index)
+def update_snps(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                snp_qual_cutoff, is_haploid, is_haplotag, read, pos, qpos, insertion_point, from_md=True):
+    """
+    update SNP information in cooper.cooper_snp_data and also for this read in read.snps
 
-        else: global_snp_positions[rpos][sub_char] = {read_index}
+    :param cooper:             cooper object
+    :param read:               read object
+    :param pos:                position of SNP on reference
+    :param qpos:               position of SNP on read
+    :param insertion_point:    dictionary of insertion positions and lengths for this read
+    :return:                   None; updates cooper.cooper_snp_data and read.snps in place
+    """
 
+    rpos = 0
+    if from_md:
+        rpos = read.ref_start + pos
 
+        for ins in insertion_point:
+            if ins < rpos:
+                qpos += insertion_point[ins]
+            # elif ins == rpos:
+            #     return  # if the SNP is next to an insertion ignore it
+            elif ins > rpos: break
+    else: rpos = pos
 
-def parse_mdtag(MD_tag, qpos, ref_start, global_read_variations, global_snp_positions, read_index, read_quality, read_sequence, sorted_global_snp_list, insertion_point):
+    if rpos in cooper_read_data[read.index].no_snps:
+        return
+    for locus in cooper_loci_keys:
+        if cooper_loci_info[locus].start <= rpos <= cooper_loci_info[locus].end:
+            return
+        if cooper_loci_info[locus].start > rpos: break
+
+    sub_qval = read.query_qualities[qpos]
+    
+    if sub_qval >= snp_qual_cutoff and (not is_haploid) and (not is_haplotag):
+        sub_char = read.query_sequence[qpos]
+        cooper_read_data[read.index].snps.add(rpos)
+
+        for read_index in cooper_prev_reads.copy():
+            _read = cooper_read_data[read_index]
+            if _read.start <= rpos <= _read.end and rpos not in _read.snps:
+                cooper_prev_reads.remove(read_index)
+
+        if rpos not in cooper_snp_data:
+            cooper_snp_data[rpos] = SNP(cov = 1, sub = { sub_char: {read.index} }, qual={ read.index: sub_qval })
+            cooper_sorted_snps.add(rpos)
+        else:
+            cooper_snp_data[rpos].cov += 1
+            cooper_snp_data[rpos].qual[read.index] = sub_qval
+            if sub_char in cooper_snp_data[rpos].sub: 
+                cooper_snp_data[rpos].sub[sub_char].add(read.index)
+
+            else: cooper_snp_data[rpos].sub[sub_char] = {read.index}
+
+
+def parse_mdtag(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                snp_qual_cutoff, is_haploid, is_haplotag, read, qpos, insertion_point):
+    """
+    parse the MD tag of a read to identify SNP positions and update cooper.cooper_snp_data and read.snps accordingly
+    :param cooper:             cooper object
+    :param read:               read object
+    :param qpos:               current position on read sequence (0-based)
+    :param insertion_point:    dictionary of insertion positions and lengths for this read
+    :return:                   None; updates cooper.cooper_snp_data and read.snps in place
+    """
         
-    if sorted_global_snp_list == None:
-        sorted_global_snp_list = []
+    if cooper_sorted_snps == None:
+        cooper_sorted_snps = SortedList()
 
     base = 0
-    sub_base='0'
-    sub_char=''
-    pos=0
+    sub_base = '0'
+    sub_char = ''
+    pos = 0
 
-    deletion = False
+    deletion  = False
     replacing = False
     
-    for i in MD_tag:
-    
+    for i in read.md_tag:
+
         if deletion:
             if i.isalpha():
-                base+=1
+                base += 1
                 continue
             else: deletion = False
-                
-        
+
         if i.isnumeric():
-            sub_base+=i
+            sub_base += i
             if sub_char != '':
-                update_global_snpPos(ref_start, pos, global_read_variations, global_snp_positions, read_index, read_sequence, read_quality, sorted_global_snp_list, insertion_point, qpos)
+                update_snps(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                            snp_qual_cutoff, is_haploid, is_haplotag, read, pos, qpos, insertion_point, True)
                 replacing = False
                 qpos+=1
                 sub_char = ''
@@ -63,7 +106,8 @@ def parse_mdtag(MD_tag, qpos, ref_start, global_read_variations, global_snp_posi
                 qpos+=int(sub_base)
             else:
                 base+=1
-                update_global_snpPos(ref_start, pos, global_read_variations, global_snp_positions, read_index, read_sequence, read_quality, sorted_global_snp_list, insertion_point, qpos)
+                update_snps(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                            snp_qual_cutoff, is_haploid, is_haplotag, read, pos, qpos, insertion_point, True)
                 pos = base - 1
                 qpos+=1
                 sub_char = ''
@@ -77,7 +121,8 @@ def parse_mdtag(MD_tag, qpos, ref_start, global_read_variations, global_snp_posi
 
             if replacing:
                 if sub_char != '':
-                    update_global_snpPos(ref_start, pos, global_read_variations, global_snp_positions, read_index, read_sequence, read_quality, sorted_global_snp_list, insertion_point, qpos)
+                    update_snps(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                                snp_qual_cutoff, is_haploid, is_haplotag, read, pos, qpos, insertion_point, True)
                     replacing = False
                     qpos+=1
                     sub_char = ''
@@ -88,4 +133,6 @@ def parse_mdtag(MD_tag, qpos, ref_start, global_read_variations, global_snp_posi
 
                 
     if sub_char != '':
-        update_global_snpPos(ref_start, pos, global_read_variations, global_snp_positions, read_index, read_sequence, read_quality, sorted_global_snp_list, insertion_point, qpos)
\ No newline at end of file
+        update_snps(cooper_snp_data, cooper_sorted_snps, cooper_loci_keys, cooper_loci_info, cooper_read_data, cooper_prev_reads,
+                    snp_qual_cutoff, is_haploid, is_haplotag, read, pos, qpos, insertion_point, True)
+    
\ No newline at end of file
diff --git a/ATARVA/merge.py b/ATARVA/merge.py
new file mode 100644
index 0000000..4dac2a9
--- /dev/null
+++ b/ATARVA/merge.py
@@ -0,0 +1,195 @@
+from math import sqrt, modf
+import sys, os
+import pysam
+import timeit as ti
+# import argparse as ap
+from multiprocessing import Process
+from ATARVA.tamatr import reader
+
+def merge_parser(subparsers):
+    parser = subparsers.add_parser("merge", help="merging multiple ATaRVa VCF files over specified regions", description="Merge ATaRVa VCF files")
+    parser._action_groups.pop()
+
+
+    required = parser.add_argument_group('Required arguments')
+    required.add_argument('-r', '--regions', required=True, metavar='<FILE>', help='input regions file. the regions file should be strictly in bgzipped tabix format. \
+                                                                  If the regions input file is in bed format. First sort it using bedtools. Compress it using bgzip. \
+                                                                  Index the bgzipped file with tabix command from samtools package.')
+    required.add_argument('-i', '--vcfs', nargs='+', required=True, metavar='<FILE>', help='text file containing paths to input vcf files to be merged. The text file should list each path on a separate line. The vcf files should be strictly in bgzipped tabix format. \
+                                                                  If the vcfs input file is in vcf format. First sort it using bcftools. Compress it using bgzip. \
+                                                                  Index the bgzipped file with tabix command from samtools package.')
+
+    required.add_argument('-f', '--fasta', required=True, metavar='<FILE>', help='input reference fasta file. The file should be indexed.')
+    optional = parser.add_argument_group('Optional arguments')
+    optional.add_argument('--contigs', nargs='+', help='contigs to get merged [chr1 chr12 chr22 ..]. If not mentioned every contigs in the region file will be merged.')
+    optional.add_argument('-o', '--outname', type=str, metavar='<STR>', default='', help='name of the output file, output is in vcf format.')
+    optional.add_argument('-t',  '--threads', type=int, metavar='<INT>', default=1, help='number of threads. [default: 1]')
+
+    if (len(sys.argv) == 2) and (sys.argv[1] == 'merge'):
+        parser.print_help()
+        sys.exit()
+
+    parser.set_defaults(func=merge_run)
+
+def shredder(threads):
+    sq_threads = sqrt(threads)
+    decimal_val, integer_value = modf(sq_threads)
+    integer_value = int(integer_value)
+    if decimal_val>0:
+        thread_list = [integer_value]*(integer_value+1)
+        remaining_threads = threads-sum(thread_list)
+        if remaining_threads>1:
+            while remaining_threads>0:
+                for i in range(len(thread_list[1:])):
+                    thread_list[i+1]+=1
+                    remaining_threads-=1
+                    if remaining_threads<=0:
+                        break
+        else:
+            thread_list[-1] += remaining_threads
+    else:
+        thread_list = [integer_value] + [integer_value-1]*(integer_value)
+        remaining_threads = threads-sum(thread_list)
+        thread_list[-1] += remaining_threads
+
+    return thread_list
+
+def merge_run(args):
+    start_time = ti.default_timer()
+    # args = parse_args()
+
+    for arg in vars(args):
+        if arg in ['func', 'command']: continue
+        print (arg, getattr(args, arg))
+    print('\n')
+    
+    out_file = sys.stdout
+    if args.outname:
+        if '.vcf' == args.outname[-4:]:
+            out_file = f'{args.outname}'[:-4]
+        elif args.outname[-1]=='/':
+            out_file = args.outname + "atarva_merged"
+        else:
+            out_file = f'{args.outname}'
+    else:
+        out_file = "atarva_merged"
+
+    vcf_list = []
+    if len(args.vcfs)==1:
+        with open(args.vcfs[0], 'r') as vh:
+            for line in vh:
+                if line[0]=='#': continue
+                line = line.strip()
+                vcf_list.append(line)
+    else:
+       vcf_list = args.vcfs 
+    
+    tbx  = pysam.Tabixfile(args.regions)
+    total_loci = 0
+    if not args.contigs:
+        contigs = sorted(tbx.contigs)
+        for row in tbx.fetch():
+            total_loci += 1
+    else:
+        contigs = sorted(args.contigs)
+        for each_contig in contigs:
+            for row in tbx.fetch(each_contig):
+                total_loci += 1
+    
+    # print('total_loci = ', total_loci)
+
+    threads = args.threads
+    threads = threads - 1
+
+    
+    split_point = 5000 if total_loci > 5000 else total_loci // 5
+    if split_point == 0:
+        split_point = 1
+        partition_point = 1
+    else:
+        partition_point = total_loci//split_point
+
+    split_point_chunks = 0 # to count number of split_point chunks excluding the 'minimum chunks' eg 9920 from 1 contig and 80 from another contig to add up to 10000
+    fetcher = []
+    line_count = 0
+    current_split = []
+    for each_contig in contigs:
+        init = 0
+        for row in tbx.fetch(each_contig):
+            line_count += 1
+            if init == 0:
+                Row = row.split('\t')
+                chrom = Row[0]
+                start_coord = (int(Row[1]), int(Row[2]))
+                init=1
+            if split_point_chunks < partition_point-1:
+                if line_count % split_point == 0:
+                    end_coord = (int(row.split('\t')[1]), int(row.split('\t')[2]))
+                    current_split.append([chrom, start_coord, end_coord])
+                    # fetcher.append(tuple(current_split))
+                    fetcher.extend(current_split)
+                    split_point_chunks += 1
+                    line_count = 0
+                    current_split = []
+                    init = 0
+        if init != 0:
+            end_coord = (int(row.split('\t')[1]), int(row.split('\t')[2]))
+            current_split.append([chrom, start_coord, end_coord])
+    # fetcher.append(tuple(current_split))
+    fetcher.extend(current_split)
+    tbx.close()
+
+    # print('Length of fetcher = ', len(fetcher))
+    # print('partition_point for fetcher = ', partition_point)
+    # fetcher = fetcher[:2]
+
+    region_file = args.regions
+    ref_file = args.fasta
+    if threads > 1:
+
+        thread_list = shredder(threads)
+        reader_thread_pool = []
+        reader_threads = thread_list[0]
+        partition = len(fetcher) // reader_threads
+        # print('reader_threads = ', reader_threads)
+        # print('partition for reading = ', partition)
+        initial = 0
+        track = partition
+        for each_reader_thread in range(reader_threads):
+            if each_reader_thread+1 == reader_threads:
+                reader_contigs = fetcher[initial : ]
+            else:
+                reader_contigs = fetcher[initial : track]
+            # print('Thread = ', each_reader_thread, ' contig length = ', len(reader_contigs))    
+            thread_x = Process(target = reader, args = (out_file, region_file, ref_file, vcf_list, reader_contigs, each_reader_thread, thread_list[each_reader_thread+1]))
+            thread_x.start()
+            reader_thread_pool.append(thread_x)
+            
+            initial = track
+            track += partition
+    
+        # joining Threads 
+        for thread_x in reader_thread_pool:
+            thread_x.join()
+        # emptying thread_pool
+        reader_thread_pool.clear()
+        #sys.exit()
+        out = open(f'{out_file}.vcf', 'a')
+        print('Concatenating thread outputs!', file=sys.stderr)
+        for tidx in range(reader_threads)[1:]:
+            thread_out = f'{out_file}_thread_{tidx}.vcf'
+            with open(thread_out, 'r') as fh:
+                # if tidx!=0: next(fh)
+                for line in fh:
+                    repeat_info = line.strip().split('\t')
+                    #print(*repeat_info, file=out, sep='\t')
+                    out.write("\t".join(map(str, repeat_info)) + "\n")
+            os.remove(thread_out)
+        out.close()
+        print('Concatenation completed!! ^_^', file=sys.stderr)
+
+    else:
+        reader(out_file, region_file, ref_file, vcf_list, fetcher, -1, 0)
+
+    time_now = ti.default_timer()
+    sys.stderr.write('CPU time: {} seconds\n'.format(time_now - start_time))
\ No newline at end of file
diff --git a/ATARVA/operation_utils.py b/ATARVA/operation_utils.py
index 14f8cac..7e3b175 100644
--- a/ATARVA/operation_utils.py
+++ b/ATARVA/operation_utils.py
@@ -1,240 +1,348 @@
-def update_homopolymer_coords(ref_seq, locus_start, homopoly_positions):
+from ATARVA.process_softclips import detect_flank
+
+
+def clean_eqsign_readseq(chrom, ref_pos, cigar_tuples, read_seq, ref):
     """
-    Record all the homopolymer stretches of at least 3 bases within the repeat coordinates
+    Convert the read sequence to replace "=" with actual bases
+
+    :param chrom: chromosome of the read
+    :param ref_pos: reference position of the read
+    :param cigar_tuples: list of cigar tuples for the read
+    :param read_seq: original read sequence with '=' placeholders
+    :param ref: reference fasta file object
+    :return: read sequence with actual bases instead of '=' placeholders
     """
-    prev_N = ref_seq[0]; start = -1
-    for i, n in enumerate(ref_seq[1:]):
-        if n == prev_N:
-            if start == -1: start = i
-        else:
-            if start != -1 and (i+1)-start >= 4:
-                for l,c in enumerate(range(locus_start+start, locus_start+i+1)):
-                    homopoly_positions[c] = (i-start+1)-l
-            start = -1
-        prev_N = n
 
-    if start != -1 and (i+1)-start >= 4:
-        for l,c in enumerate(range(locus_start+start, locus_start+i+1)):
-            # for each position in the homopolymer stretch we record the length of the 
-            # homopolymer nucleotides on the right
-            homopoly_positions[c] = (i-start+1)-l
+    new_read_seq = []
+    qpos = 0
+
+    CIGAR_ACTIONS = {4, 1, 2, 0, 7, 8}
+
+    for op, length in cigar_tuples:
+        if op in (4, 1):                                         # S, I — copy from read
+            new_read_seq.append(read_seq[qpos:qpos + length])
+            qpos += length
+
+        elif op == 2:                                            # D — advance ref only
+            ref_pos += length
+
+        elif op in (0, 7):                                       # M, = — fetch from ref
+            ref_end    = ref_pos + length
+            inter_ref  = ref.fetch(chrom, ref_pos, ref_end)
+
+            if op == 7:                                          # = exact match, use ref
+                new_read_seq.append(inter_ref)
+            else:                                                # M resolve '=' placeholders
+                segment = read_seq[qpos:qpos + length]
+                new_read_seq.append(''.join(
+                    inter_ref[i] if base == '=' else base
+                    for i, base in enumerate(segment)
+                ))
+
+            ref_pos  = ref_end
+            qpos       += length
+
+        elif op == 8:                                            # X — mismatch, use read
+            new_read_seq.append(read_seq[qpos:qpos + length])
+            ref_pos += length
+            qpos    += length
 
+    return ''.join(new_read_seq)
 
-def match_jump(rpos, repeat_index, loci_coords, tracked, locus_qpos_range, qpos, match_len, loci_flank_qpos_range, flank_track, left_flank, right_flank):
+
+def record_homopolymers(ref_seq, locus_start, homopolymer_positions, threshold=3):
+    """
+    Update the homopolymer positions for a given reference sequence and locus start position
+    For each position part of the homopolymer, the length of the homopolymer from the at position is stored
+
+    :param ref_seq: reference sequence for the locus
+    :param locus_start: start position of the locus in the reference
+    :param homopolymer_positions: dictionary to store the homopolymer positions
+    :param threshold: minimum length of homopolymer to be considered (default is 3)    
+    """
+
+    i = 0
+    while i < len(ref_seq):
+        j = i
+        # extend j while same base
+        while j < len(ref_seq) and ref_seq[j] == ref_seq[i]:
+            j += 1
+
+        length = j - i
+        if length >= threshold:
+            for offset in range(length):
+                homopolymer_positions[locus_start + i + offset] = length - offset
+
+
+def match_jump(read, match_refend, match_qryend, match_length, repeat_index, locus_query_range,
+               flank_query_range, locus_reached, locus_boundary_crossed):
     """
-    Return the number of repeat indices to jump when scanning through a match segment
+    process a match and update data for affected repeats
+
+    :param read: the read being processed
+    :param match_refend: the reference end position of the match
+    :param match_qryend: the query end position of the match
+    :param match_length: length of the match
+    :param repeat_index: the current repeat index being processed
+    :param locus_query_range: list of query position ranges for each locus in the read
+    :param flank_query_range: list of query position ranges for the flanks of each locus in the read
+    :param locus_reached: list of bools storing if reached the locus scanning the cigar
+    :param locus_boundary_crossed: bools indicating if the repeat boundaries have been crossed scanning the cigar
+    :return: number of repeat indices to jump after processing the match segment
     """
 
+    match_refstart = match_refend - match_length
     r = 0 
-    for r,coord in enumerate(loci_coords[repeat_index:]):
-        
-        if rpos < coord[0]: break
-        previous_rpos = rpos - match_len
-        if previous_rpos > coord[1]: continue
+    for r, coord in enumerate(read.loci_coords[repeat_index:]):
+        current_index = r + repeat_index
+        flank_start, flank_end = coord
+        locus_start = flank_start + read.left_flanks[current_index]
+        locus_end = flank_end - read.right_flanks[current_index]
+
+        # if the match segment is before the start of the repeat; repeat is unaffected
+        if match_refend < flank_start: break
+
+        # if the match segment is beyond the end of the repeat; repeat is unaffected
+        if match_refstart > flank_end: continue
             
-        if not tracked[r+repeat_index]:
+        if not locus_reached[current_index]:
 
-            if coord[0] <= rpos:
-                
-                locus_qpos_range[r+repeat_index][0] = qpos - (rpos - coord[0])
-            if coord[1] < rpos:
-                
-                locus_qpos_range[r+repeat_index][1] = qpos - (rpos - coord[1])
+            if flank_start <= match_refend:
+                flank_query_range[current_index][0] = match_qryend - (match_refend - flank_start)
 
-            tracked[r+repeat_index] = True 
+            if flank_end <= match_refend:
+                flank_query_range[current_index][1] = match_qryend - (match_refend - flank_end)
 
-            # for storing repeat qpos ranges
-            if coord[0]+left_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos - (rpos - coord[0])+left_flank[r+repeat_index]
-                flank_track[r+repeat_index][0] = True
-            if coord[1]-right_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos - (rpos - coord[1])-right_flank[r+repeat_index]
-                if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
-                
-                
-
-        elif coord[1] <= rpos:
-            
-            locus_qpos_range[r+repeat_index][1] = qpos - (rpos - coord[1])
+            locus_reached[current_index] = True
+
+            if not locus_boundary_crossed[current_index][0]:
+                if locus_start <= match_refend:
+                    locus_query_range[current_index][0] = match_qryend - (match_refend - locus_start)
+                    locus_boundary_crossed[current_index][0] = True
+            if not locus_boundary_crossed[current_index][1]:
+                if locus_end <= match_refend:
+                    locus_query_range[current_index][1] = match_qryend - (match_refend - locus_end)
+                    # the postion is greater than the end to consider inserts at the end of the repeat
+                    if match_refend > locus_end: locus_boundary_crossed[current_index][1] = True
+
+        elif flank_end <= match_refend:
+            flank_query_range[current_index][1] = match_qryend - (match_refend - flank_end)
 
         # for storing repeat qpos ranges
-        if not flank_track[r+repeat_index][0]:
-            if coord[0]+left_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos - (rpos - coord[0])+left_flank[r+repeat_index]
-                flank_track[r+repeat_index][0] = True 
-            if coord[1]-right_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos - (rpos - coord[1])-right_flank[r+repeat_index]
-                if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
-            
-        elif (not flank_track[r+repeat_index][1]) and (coord[1]-right_flank[r+repeat_index] <= rpos):
-            loci_flank_qpos_range[r+repeat_index][1] = qpos - (rpos - coord[1])-right_flank[r+repeat_index]
-            if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
+        if not locus_boundary_crossed[current_index][0]:
+            if locus_start <= match_refend:
+                locus_query_range[current_index][0] = match_qryend - (match_refend - locus_start)
+                locus_boundary_crossed[current_index][0] = True
+            if locus_end <= match_refend:
+                locus_query_range[current_index][1] = match_qryend - (match_refend - locus_end)
+                if match_refend > locus_end: locus_boundary_crossed[current_index][1] = True
+
+        elif not locus_boundary_crossed[current_index][1]:
+            if locus_end <= match_refend:
+                locus_query_range[current_index][1] = match_qryend - (match_refend - locus_end)
+                if match_refend > locus_end: locus_boundary_crossed[current_index][1] = True
 
-    
     jump = 0    # jump beyond the repeat where all positions are tracked
-    if loci_coords[repeat_index + r - 1][1] < rpos:
-        for f in loci_coords[repeat_index:]:
-            if f[1] < rpos: jump += 1
+    if read.loci_coords[repeat_index + r - 1][1] < match_refend:
+        for f in read.loci_coords[repeat_index:]:
+            if f[1] < match_refend: jump += 1
             else: break
-    
+
     return jump
 
 
-def deletion_jump(deletion_length, rpos, repeat_index, loci_keys, tracked, loci_coords, homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank, right_flank):
+def deletion_jump(read, del_refend, qpos, deletion_len, repeat_index, locus_query_range, flank_query_range, locus_reached, locus_boundary_crossed):
     """
-    Return the number of repeat indices to jump when scanning through a deletion segment.
-    The function tracks specifically if the deletion is segment has complete repeats in them
-    or segments of the repeat is deleted.
+    process a deletion and update data for affected repeats
+
+    :param read: the read being processed
+    :param del_refend: the reference end position of the deletion
+    :param qpos: the query position corresponding to the reference end position of the deletion
+    :param deletion_len: length of the deletion
+    :param repeat_index: the current repeat index being processed
+    :param locus_query_range: list of query position ranges for each locus in the read
+    :param flank_query_range: list of query position ranges for the flanks of each locus in the read
+    :param locus_reached: list of bools storing if reached the locus scanning the cigar
+    :param locus_boundary_crossed: bools indicating if the repeat boundaries have been crossed scanning the cigar
+    :return: number of repeat indices to jump after processing the deletion segment
     """
 
-    # rpos - corresponds to the position in the reference after tracking the deletion
+    del_refstart = del_refend - deletion_len
+
     r = 0   # required to be initialised outside the loop
-    for r, coord in enumerate(loci_coords[repeat_index:]):
+    for r, coord in enumerate(read.loci_coords[repeat_index:]):
+        current_index = r + repeat_index
+
+        flank_start, flank_end = coord  # the locus coordinates include flanks
+        locus_start = flank_start + read.left_flanks[current_index]
+        locus_end = flank_end - read.right_flanks[current_index]
+
         # if rpos is before the start of the repeat; repeat is unaffected
-        if rpos < coord[0]: break
+        if del_refend < flank_start: break
 
         # actual position in the reference where the deletion is occurring
-        del_pos = rpos - deletion_length
-        if del_pos > coord[1]: continue
+        if del_refstart > flank_end: continue
 
-        locus_key = loci_keys[r+repeat_index]
-        if not tracked[r+repeat_index]:
-            # if the locus is not tracked
-            # deletion is encountered beyond
-            if coord[0] <= rpos:    
-                locus_qpos_range[r+repeat_index][0] = qpos        
-                tracked[r+repeat_index] = True    # set tracked as true
+        locus_key = read.loci_keys[current_index]
+        if not locus_reached[current_index]:
+            # if the locus is not tracked so far
+            if locus_start <= del_refend:    
+                flank_query_range[current_index][0] = qpos        
+                locus_reached[current_index] = True    # set tracked as true
 
-            if coord[1] < rpos:
-                
-                locus_qpos_range[r+repeat_index][1] = qpos
+            if locus_end < del_refend:
+                flank_query_range[current_index][1] = qpos
 
             # for storing repeat qpos ranges
-            if coord[0]+left_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos
-                flank_track[r+repeat_index][0] = True
-            if coord[1]-right_flank[r+repeat_index] < rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos
-                flank_track[r+repeat_index][1] = True
-
-        elif coord[1] < rpos:
-            
-            locus_qpos_range[r+repeat_index][1] = qpos
+            if not locus_boundary_crossed[current_index][0]:
+                if locus_start <= del_refend:
+                    locus_query_range[current_index][0] = qpos
+                    locus_boundary_crossed[current_index][0] = True
+            if not locus_boundary_crossed[current_index][1]:
+                # should probably be locus_end < del_refend because locus_end includes flank
+                if locus_end < del_refend:
+                    locus_query_range[current_index][1] = qpos
+                    locus_boundary_crossed[current_index][1] = True
+
+        elif flank_end < del_refend:
+            flank_query_range[current_index][1] = qpos
 
         # for storing repeat qpos ranges
-        if not flank_track[r+repeat_index][0]:
-            if coord[0]+left_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos
-                flank_track[r+repeat_index][0] = True 
-            if coord[1]-right_flank[r+repeat_index] < rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos
-                flank_track[r+repeat_index][1] = True
-        elif (not flank_track[r+repeat_index][1]) and (coord[1]-right_flank[r+repeat_index] <= rpos):
-            loci_flank_qpos_range[r+repeat_index][1] = qpos
-            if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
-
-        # updating the allele with the deletion considered
-        # read_loci_variations[locus_key][rpos] = f'D|{deletion_length}'
-        
-        # del_len = min(coord[1], rpos) - max(coord[0], del_pos)
-        del_len = min(coord[1]-right_flank[r+repeat_index], rpos) - max(coord[0]+left_flank[r+repeat_index], del_pos)
-        if (rpos >= coord[0]+left_flank[r+repeat_index]) and (del_pos <= coord[1]-right_flank[r+repeat_index]): # introduced to include length only if it comes inside repeat region
-            if del_pos not in homopoly_positions:
-                read_loci_variations[locus_key]['alen'] -= del_len
-                read_loci_variations[locus_key]['halen'] -= del_len
+        if not locus_boundary_crossed[current_index][0]:
+            if locus_start <= del_refend:
+                locus_query_range[current_index][0] = qpos
+                locus_boundary_crossed[current_index][0] = True
+            if locus_end < del_refend:
+                locus_query_range[current_index][1] = qpos
+                locus_boundary_crossed[current_index][1] = True
+        elif not locus_boundary_crossed[current_index][1]:
+            if locus_end <= del_refend:
+                locus_query_range[current_index][1] = qpos
+                if del_refend > locus_end: locus_boundary_crossed[current_index][1] = True
+
+        # if deletion does not overlap the repeat; skip
+        if del_refend < locus_start or del_refstart > locus_end:
+            continue
+        else:
+            # updating the allele with the deletion considered
+            del_len = min(locus_end, del_refend) - max(locus_start, del_refstart)
+            if del_refstart not in read.homopolymer_positions:
+                read.loci_data[locus_key].alen  -= del_len
+                read.loci_data[locus_key].halen -= del_len
             else:
-                if del_len <= homopoly_positions[del_pos]:
-                    # if the deletion is only limited to the homopolymer positions
-                    read_loci_variations[locus_key]['halen'] -= del_len
+                # if the deletion is only limited to the homopolymer positions
+                if del_len <= read.homopolymer_positions[del_refstart]:
+                    read.loci_data[locus_key].halen -= del_len
                 else:
-                    read_loci_variations[locus_key]['alen'] -= del_len
-                    read_loci_variations[locus_key]['halen'] -= del_len
-
+                    read.loci_data[locus_key].alen  -= del_len
+                    read.loci_data[locus_key].halen -= del_len
 
     jump = 0    # jump beyond the repeat where all positions are tracked
-    if loci_coords[repeat_index + r - 1][1] < rpos:
-        for f in loci_coords[repeat_index:]:
-            if f[1] < rpos: jump += 1
+    if read.loci_coords[repeat_index + r - 1][1] < del_refend:
+        for coord in read.loci_coords[repeat_index:]:
+            if coord[1] < del_refend: jump += 1
             else: break
 
     return jump
 
 
-def insertion_jump(insertion_length, insert, rpos, repeat_index, loci_keys, tracked, loci_coords, homopoly_positions, read_loci_variations, locus_qpos_range, qpos, loci_flank_qpos_range, flank_track, left_flank, right_flank, out_insertion_qpos_ranges_left, out_insertion_qpos_ranges_right, left_ins_rpos, right_ins_rpos):
+def insertion_jump(read, ins_refpos, ins_qend, insert_len, homopolymer_insert, repeat_index, locus_query_range, flank_query_range,
+                   locus_reached, locus_boundary_crossed, left_flank_insertions, right_flank_insertions):
     """
-    Return the number of repeat indices to jump when scanning through a insertion segment.
-    The function tracks specifically if the deletion is segment has complete repeats in them
-    or segments of the repeat is deleted.
+    process an insertion and update data for affected repeats
+    :param read: the read being processed
+    :param ins_refpos: the reference position where the insertion is occurring
+    :param ins_qend: the query end position of the insertion
+    :param insert_len: length of the insertion
+    :param homopolymer_insert: boolean indicating if the insertion is a homopolymer    :param repeat_index: the current repeat index being processed
+    :param locus_query_range: list of query position ranges for each locus in the read
+    :param flank_query_range: list of query position ranges for the flanks of each locus in the read
+    :param locus_reached: list of bools storing if reached the locus scanning the cigar
+    :param locus_boundary_crossed: bools indicating if the repeat boundaries have been crossed scanning the cigar
+    :param left_flank_insertions: list of insertions in the left flank for each locus
+    :param right_flank_insertions: list of insertions in the right flank for each locus
+    :return: number of repeat indices to jump after processing the insertion segment
     """
+
+    ins_qstart = ins_qend - insert_len  # start position of the insertion in the query
+
     r = 0   # required to be initialised outside the loop
-    for r, coord in enumerate(loci_coords[repeat_index:]):
+    for r, coord in enumerate(read.loci_coords[repeat_index:]):
+        current_index = r + repeat_index
+
+        flank_start, flank_end = coord
+        locus_start = flank_start + read.left_flanks[current_index]
+        locus_end = flank_end - read.right_flanks[current_index]
         # if rpos is before the start of the repeat; repeat is unaffected
-        if rpos < coord[0]: break
+        if ins_refpos < flank_start: break
 
         # if the insertion is happening beyond, the repeat in unaffected
-        if rpos > coord[1]: continue
-
-        locus_key = loci_keys[r+repeat_index]
-        if not tracked[r+repeat_index]:
-            # if the locus is not tracked
-            # deletion is encountered beyond
-            if coord[0] <= rpos:
-                locus_qpos_range[r+repeat_index][0] = qpos-insertion_length
-                tracked[r+repeat_index] = True    # set tracked as true
-            if coord[1] == rpos:
-               
-                locus_qpos_range[r+repeat_index][1] = qpos
-                # here jump can be done
+        if ins_refpos > flank_end: continue
+
+        locus_key = read.loci_keys[current_index]
+        if not locus_reached[current_index]:
+            if flank_start <= ins_refpos:      # can this be locus_start - 1??
+                flank_query_range[current_index][0] = ins_qstart
+                locus_reached[current_index] = True    # set tracked as true
+
+            if flank_end == ins_refpos:
+                flank_query_range[current_index][1] = ins_qend
 
             # for storing repeat qpos ranges
-            if coord[0]+left_flank[r+repeat_index]-1 <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos-insertion_length
-                flank_track[r+repeat_index][0] = True
-            if coord[1]-right_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos
-                if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
+            if not locus_boundary_crossed[current_index][0]:
+                if locus_start - 1 <= ins_refpos:
+                    locus_query_range[current_index][0] = ins_qstart
+                    locus_boundary_crossed[current_index][0] = True
+            if not locus_boundary_crossed[current_index][1]:
+                if locus_end <= ins_refpos:
+                    locus_query_range[current_index][1] = ins_qend
+                    if ins_refpos > flank_end: locus_boundary_crossed[current_index][1] = True
 
 
-        elif coord[1] == rpos:
-            
-            locus_qpos_range[r+repeat_index][1] = qpos
+        elif flank_end == ins_refpos:
+            flank_query_range[current_index][1] = ins_qend
 
         # for storing repeat qpos ranges
-        if not flank_track[r+repeat_index][0]:
-            if coord[0]+left_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][0] = qpos-insertion_length
-                flank_track[r+repeat_index][0] = True 
-            if coord[1]-right_flank[r+repeat_index] <= rpos:
-                loci_flank_qpos_range[r+repeat_index][1] = qpos
-                if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
-        elif (not flank_track[r+repeat_index][1]) and (coord[1]-right_flank[r+repeat_index] <= rpos):
-            loci_flank_qpos_range[r+repeat_index][1] = qpos
-            if rpos > coord[1]-right_flank[r+repeat_index]: flank_track[r+repeat_index][1] = True
+        if not locus_boundary_crossed[current_index][0]:
+            if locus_start <= ins_refpos:
+                locus_query_range[current_index][0] = ins_qstart
+                locus_boundary_crossed[current_index][0] = True
+            if locus_end <= ins_refpos:
+                locus_query_range[current_index][1] = ins_qend
+                if ins_refpos > locus_end: locus_boundary_crossed[current_index][1] = True
+        elif not locus_boundary_crossed[current_index][1]:
+            if locus_end <= ins_refpos:
+                locus_query_range[current_index][1] = ins_qend
+                if ins_refpos > locus_end: locus_boundary_crossed[current_index][1] = True
 
         # read_loci_variations[locus_key][rpos] = f'I|{insertion_length}'
-        if coord[0]+left_flank[r+repeat_index] <= rpos <= coord[1]-right_flank[r+repeat_index]: # introduced to include length only if it comes inside repeat region
-            if rpos not in homopoly_positions:
-                read_loci_variations[locus_key]['alen'] += insertion_length
-                read_loci_variations[locus_key]['halen'] += insertion_length
+        if locus_start <= ins_refpos <= locus_end: # introduced to include length only if it comes inside repeat region
+            if ins_refpos not in read.homopolymer_positions:
+                read.loci_data[locus_key].alen  += insert_len
+                read.loci_data[locus_key].halen += insert_len
             else:
-                if len(set(insert)) == 1:
+                if homopolymer_insert:
                     # only if the insertion is a homopolymer; consider it as homopolymer insertion
-                    read_loci_variations[locus_key]['halen'] += insertion_length
+                    read.loci_data[locus_key].halen += insert_len
                 else:
-                    read_loci_variations[locus_key]['alen'] += insertion_length
-                    read_loci_variations[locus_key]['halen'] += insertion_length
-
-        if coord[0] <= rpos <= coord[0]+left_flank[r+repeat_index]-1: # -1 is included so ins near the start pos is not taken into account as it is already added
-            out_insertion_qpos_ranges_left[r+repeat_index].append((qpos-insertion_length, qpos))
-            left_ins_rpos[r+repeat_index].append(rpos)
-        elif coord[1]-right_flank[r+repeat_index]+1 <= rpos <= coord[1]: # +1 is included so ins near the end pos is not taken into account as it is already added
-            out_insertion_qpos_ranges_right[r+repeat_index].append((qpos-insertion_length, qpos))
-            right_ins_rpos[r+repeat_index].append(rpos)
+                    read.loci_data[locus_key].alen  += insert_len
+                    read.loci_data[locus_key].halen += insert_len
+
+        if flank_start <= ins_refpos <= locus_start - 1: # -1 is included so ins near the start pos is not taken into account as it is already added
+            try:
+                left_flank_insertions[current_index].append((ins_refpos, ins_qstart, ins_qend))
+            except AttributeError:
+                pass
+        elif locus_end + 1 <= ins_refpos <= flank_end: # +1 is included so ins near the end pos is not taken into account as it is already added
+            try:
+                right_flank_insertions[current_index].append((ins_refpos, ins_qstart, ins_qend))
+            except AttributeError:
+                pass
 
     jump = 0    # jump beyond the repeat where all positions are tracked
-    if loci_coords[repeat_index + r - 1][1] < rpos:
-        for f in loci_coords[repeat_index:]:
-            if f[1] < rpos: jump += 1
+    if read.loci_coords[repeat_index + r - 1][1] < ins_refpos:
+        for f in read.loci_coords[repeat_index:]:
+            if f[1] < ins_refpos: jump += 1
             else: break
 
-    return jump
\ No newline at end of file
+    return jump
diff --git a/ATARVA/process_softclips.py b/ATARVA/process_softclips.py
new file mode 100644
index 0000000..fb3e467
--- /dev/null
+++ b/ATARVA/process_softclips.py
@@ -0,0 +1,667 @@
+import parasail
+import cstag
+import numpy as np
+
+from ATARVA.realignment import *
+
+
+def generate_md_tag(cigar, reference, query):
+    """
+    generate MD tag from CIGAR, reference/target sequence, and query/read sequence.
+
+    :param cigar: CIGAR string (e.g., "10M1I5M2D8M")
+    :param target: reference-aligned sequence span consumed by CIGAR ref ops
+    :param query: read-aligned sequence span consumed by CIGAR query ops
+    :return: MD tag string (e.g., "10A5^CT8")
+    """
+    qpos = 0
+    rpos = 0
+
+    prev_op = None
+
+    md = []
+    match_count = 0
+
+    i = 0
+    while i < len(cigar):
+        # parse length
+        mismatch = False
+        num = ''
+        while i < len(cigar) and cigar[i].isdigit():
+            num += cigar[i]
+            i += 1
+        if num == '': num = 0
+        else: num = int(num)
+        op = cigar[i]
+        i += 1
+
+        if op == '=':
+            match_count += num
+            qpos += num
+            rpos += num
+
+        elif op == 'X':
+            if prev_op in ('X', 'D'):
+                md.append('0')
+            for _ in range(num):
+                if match_count > 0:
+                    md.append(str(match_count))
+                    match_count = 0
+                if prev_op == 'X' and md[-1] != '0': md.append('0')
+                md.append(reference[rpos])
+                prev_op = 'X'
+                qpos += 1
+                rpos += 1
+
+        elif op == 'D':
+            if prev_op in ('X', 'D'):
+                md.append('0')
+            if match_count > 0:
+                md.append(str(match_count))
+                match_count = 0
+            md.append("^" + reference[rpos:rpos+num])
+            rpos += num
+
+        elif op == 'I':
+            # insertion: only consumes query
+            qpos += num
+
+        elif op == 'M':
+            # fallback if M is present
+            for _ in range(num):
+                if query[qpos] == reference[rpos]:
+                    mismatch = False
+                    match_count += 1
+                else:
+                    if _ == 0 and prev_op in ('X', 'D'):
+                        md.append('0')
+                    mismatch = True
+                    if match_count > 0:
+                        md.append(str(match_count))
+                        match_count = 0
+                    md.append(reference[rpos])
+                qpos += 1
+                rpos += 1
+        
+        elif op == 'S':
+            # soft clip: only consumes query, not represented in MD
+            qpos += num
+        
+        prev_op = op
+        if mismatch: prev_op = 'X'
+
+    if match_count > 0:
+        md.append(str(match_count))
+
+    return ''.join(md)
+
+
+def join_cstags(cs_left: str, cs_right: str) -> str:
+    """
+    join two continuous minimap2 cs tags (short format) and normalize.
+
+    Supports tokens:
+      :<num>   match length
+      *ac      substitution
+      +acgt    insertion
+      -acgt    deletion
+      ~gt12ag  intron/splice
+
+    Example:
+      cs_left=":10+aa:5"
+      cs_right=":3-tt:7"
+      -> ":10+aa:8-tt:7"
+    
+    :param cs_left:  left cs tag fragment (e.g., ":10+aa:5")
+    :param cs_right: right cs tag fragment (e.g., ":3-tt:7")
+    :return:         joined cs tag (e.g., ":10+aa:8-tt:7")
+    """
+
+    operations = {':', '-', '+', '*', '=', '~'}
+    left_op    = ''
+    left_opdat = ''
+    for x in cs_left[::-1]:
+        if x in operations:
+            left_op = x; break
+        left_opdat = x + left_opdat
+
+    right_op = ''
+    right_opdat = ''
+    for x in cs_right:
+        if x in operations:
+            if not right_op:
+                right_op = x
+            else: break
+        else:
+            right_opdat += x
+
+    if left_op == right_op:
+        if left_op == '*':
+            return cs_left + cs_right
+        elif left_op == ':':
+            merged_opdat = str(int(left_opdat) + int(right_opdat))
+        else:
+            merged_opdat = left_opdat + right_opdat
+        return cs_left[:-len(left_opdat)-1] + left_op + merged_opdat + cs_right[len(right_opdat)+1:]
+    else:
+        return cs_left + cs_right
+
+
+def right_md_token(md):
+    i = 0
+    if md[i].isdigit():
+        num = ''
+        while i < len(md) and md[i].isdigit():
+            num += md[i]; i += 1
+        return int(num), i
+
+    elif md[i] == '^':
+        i += 1
+        seq = ''
+        while i < len(md) and md[i].isalpha():
+            seq += md[i]; i += 1
+        return '^' + seq, i
+    else:
+        return md[i], i + 1
+
+def left_md_token(md):
+    i = len(md) - 1
+    if md[i].isdigit():
+        num = ''
+        while i >= 0 and md[i].isdigit():
+            num = md[i] + num
+            i -= 1
+        return int(num), i + 1 
+
+    else:
+        if i > 0 and md[i-1] == '0':
+            return md[i], i
+        seq = ''
+        while i >= 0 and md[i] != '^':
+            seq = md[i] + seq
+            i -= 1
+        return '^' + seq, i
+
+
+def join_mdtags(md1, md2):
+    t1, t1_idx = left_md_token(md1)
+    t2, t2_idx = right_md_token(md2)
+
+    if not t1:
+        return md2
+    if not t2:
+        return md1
+
+    merged = ''
+    # merge boundary numbers
+    if isinstance(t1, int) and isinstance(t2, int):
+        merged = t1 + t2
+    elif not isinstance(t1, int) and not isinstance(t2, int):
+        if t1[0] == '^' and t2[0] == '^':
+            merged = t1 + t2[1:]
+        else:
+            merged = t1 + '0' + t2
+    else:
+        merged = str(t1) + str(t2)
+
+    return md1[:t1_idx] + str(merged) + md2[t2_idx:]
+
+
+def join_cigars(cigar_left: str, cigar_right: str) -> str:
+    """
+    join two continuous CIGAR strings and normalize.
+    :param cigar_left:  left CIGAR string (e.g., "10M1I5M")
+    :param cigar_right: right CIGAR string (e.g., "2M3D8M")
+    :return:            joined CIGAR string (e.g., "10M1I7M3D8M")
+    """
+
+    operations = {'M', 'I', 'D', 'N', 'S', 'H', 'P', '=', 'X'}
+    left_op    = ''
+    left_opdat = ''
+    left_index = len(cigar_left)
+    for x in cigar_left[::-1]:
+        if x in operations:
+            if left_op == '':
+                left_op = x
+            else: break
+        else:
+            left_opdat = x + left_opdat
+        left_index -= 1
+
+    right_op = ''
+    right_opdat = ''
+    right_index = 0
+    for x in cigar_right:
+        if x in operations:
+            right_op = x
+            right_index += 1; break
+        else:
+            right_opdat += x
+        right_index += 1
+
+    if left_op == right_op:
+        merged_opdat = str(int(left_opdat) + int(right_opdat))
+        return cigar_left[:left_index] + merged_opdat + left_op + cigar_right[right_index:]
+    else:
+        return cigar_left + cigar_right
+
+
+def nw_align(query: str, target: str, gap_open: int = 6, gap_extend: int = 3) -> tuple[str, int]:
+    """
+    Needleman-Wunsch global alignment returning CIGAR and score.
+
+    :param query:      query sequence
+    :param target:     reference sequence
+    :param gap_open:   gap open penalty
+    :param gap_extend: gap extend penalty
+    :return:           (cigar_string, alignment_score)
+    """
+    score_matrix = parasail.matrix_create("ACGT", 2, -2)  # simple match/mismatch scoring
+    result = parasail.nw_trace(
+        query, target,
+        gap_open, gap_extend,
+        score_matrix        # DNA scoring matrix
+    )
+    return result.cigar.decode.decode('utf-8'), result.score
+
+
+def _edit_distance(cigar: str):
+    """
+    calculate edit distance from CIGAR string (considering M/I/D/X as edit operations)
+
+    :param cigar: CIGAR string (e.g., "10M1I5M2D8M")
+    :return:      edit distance
+    """
+
+    length = ''
+    edit_distance = 0
+
+    for c in cigar:
+        if c.isdigit():
+            length += c
+            continue
+        else:
+            if c in ('I', 'D', 'X'): edit_distance += int(length)
+            length = ''
+    
+    return edit_distance
+
+
+def _match_lengths(cigar: str):
+    """
+    list of match lengths from CIGAR string (considering M/= as matches)
+    NOTE: if X in CIGAR it is merged into M
+
+    :param cigar: CIGAR string (e.g., "10M1I5M2D8M")
+    :return:      list of match lengths (e.g., [10, 5, 8])
+    """
+
+
+    length = ''
+    match_break = False
+    prev_op  = None
+    prev_len = 0
+
+    match_lengths = []
+    match_length = 0
+
+    for c in cigar:
+        if c.isdigit():
+            length += c
+            continue
+        else:
+            if c == 'M' or c == '=':
+                match_length = int(length)
+                if match_break and prev_op == 'X':
+                    match_length += prev_len
+                match_break = False
+            if c == 'X':
+                if match_break: pass
+                else:
+                    match_length += int(length)
+            if c in ('I', 'D'):
+                if match_length > 0: match_lengths.append(match_length)
+                match_break = True
+                match_length = 0
+            prev_op = c
+            prev_len = int(length)
+            length = ''
+    
+    return match_lengths
+
+
+def _collapse_mismatches(cigar: str, match_char: str):
+    """
+    collapse mismatches within matches in CIGAR string
+
+    :param cigar: CIGAR string (e.g., "10M1I5M2D8M")
+    :param match_char: character to represent matches (e.g., 'M' or '=')
+
+    :return collapsed CIGAR string
+    """
+
+    length = ''
+    prev_op  = None
+
+    match_length = 0
+    new_cigar = ''
+
+    for c in cigar:
+        if c.isdigit():
+            length += c
+            continue
+        else:
+            if c == 'M' or c == '=' or c == 'X':
+                match_length += int(length)
+
+            elif c in ('I', 'D'):
+                if match_length > 0:
+                    new_cigar += f'{match_length}{match_char}'
+                    match_length = 0
+                new_cigar += f'{length}{c}'
+                match_length = 0
+            elif c == 'S':
+                new_cigar += f'{length}S'
+            prev_op = c
+            length = ''
+    if match_length > 0:
+        new_cigar += f'{match_length}{match_char}'
+
+    return new_cigar
+
+
+def _cigar_tuples(cigar: str):
+    length = ''
+    cigar_map = {'M': 0, 'I': 1, 'D': 2, 'N': 3, 'S': 4, 'H': 5, 'P': 6, '=': 7, 'X': 8, 'B': 9}
+    cigar_tuples = []
+
+    for c in cigar:
+        if c.isdigit():
+            length += c
+            continue
+        else:
+            cigar_tuples.append((cigar_map[c], int(length)))
+            length = ''
+
+    return cigar_tuples
+
+
+def _query_length(cigartuples: list[tuple[int, int]]):
+    query_length = 0
+    for op, length in cigartuples:
+        if op in (0, 1, 4, 7, 8): # M/I/S/=/X consume query
+            query_length += length
+    return query_length
+
+def _ref_length(cigartuples: list[tuple[int, int]]):
+    ref_length = 0
+    for op, length in cigartuples:
+        if op in (0, 2, 3, 7, 8): # M/D/N/=/X consume reference
+            ref_length += length
+    return ref_length
+
+
+def strip_softclip(cigar: str, dir: str) -> tuple[str, int]:
+    """
+    strip leading and trailing soft-clips from CIGAR string
+
+    :param cigar: CIGAR string (e.g., "10S90M5S")
+    :param dir: direction of soft-clip to strip ("left" or "right" or "both")
+    :return:      stripped CIGAR string
+    """
+
+    left_softclip_length = 0
+    right_softclip_length = 0
+
+    if dir in ("right", "both") and cigar.endswith('S'):
+        i = len(cigar) - 2
+        while i >= 0 and cigar[i].isdigit():
+            i -= 1
+        right_softclip_length = int(cigar[i+1:-1])
+        cigar = cigar[:i+1]
+
+    if dir in ("left", "both"):
+        length = ''
+        for i, c in enumerate(cigar):
+            if c.isdigit():
+                continue
+            elif c == 'S':
+                i += 1; break
+            else:
+                return cigar
+        cigar = cigar[i:]
+
+    return cigar
+
+
+def md_stats(md):
+    matches = 0
+    mismatches = 0
+    deletions = 0
+
+    i = 0
+    while i < len(md):
+        if md[i].isdigit():
+            num = ""
+            while i < len(md) and md[i].isdigit():
+                num = num + md[i]
+                i += 1
+            matches += int(num)
+        elif md[i] == '^':
+            i += 1
+            while i < len(md) and md[i].isalpha():
+                deletions += 1
+                i += 1
+        else:
+            mismatches += 1
+            i += 1
+
+    return matches, mismatches, deletions
+
+
+def cigar_stats(cigar):
+    match_len = 0
+    del_len = 0
+
+    length = ''
+    op = ''
+    for c in cigar:
+        if c.isdigit():
+            length += c
+        else:
+            op = c
+            if op in ('M', '=', 'X'):
+                match_len += int(length)
+            elif op == 'D':
+                del_len += int(length)
+            length = ''
+            op = ''
+
+    return match_len, del_len
+
+
+def valid_md(md, cigar):
+    m, x, d_md = md_stats(md)
+    m_cigar, d_cigar = cigar_stats(cigar)
+
+    return (m + x == m_cigar) and (d_md == d_cigar)
+
+
+def detect_flank(cooper, read, locus_start, locus_end, stream):
+    """
+    Identify the flanking sequences of the repeat region in the read
+    Args:
+        read: pysam read object
+        fasta: pysam fasta object
+        flank_length: length of the flanking sequence to be considered
+        locus_start: start coordinate of the repeat in reference
+        locus_end: end coordinate of the repeat in reference
+
+    Returns:
+        [start, end, sub_cigar]
+        start and end coordinates of the flanking sequence in the read
+        sub_cigar: CIGAR string of the repeat alignment to the reference in the read
+    """
+
+    flank = 50
+    score_threshold = int(2*(0.9*flank))
+
+    if stream: # if its upstream (True)
+
+        # finding the upstream flank in the read 
+        upstream = cooper.ref.fetch(read.chrom, locus_start - flank, locus_start)
+        alignment_score, target_begin, target_end, query_begin, query_end, sCigar = stripSW(Inputs(read.query_sequence, upstream), False)
+
+        # target_begin is the start of the alignment in the read
+        # query_begin  is the start of the alignment in the reference flank
+        # target_end   is the end of the alignment in the read
+        # query_end    is the end of the alignment in the reference flank
+
+        # if the upstream flank aligns to the already aligned region(by aligner), there is no expansion in the soft-clip, here target_end is dummy
+        if target_end > read.query_start: return [-1, -1]
+
+        # reject read if less than 70% match with the reference flank sequence
+        if alignment_score < score_threshold: return [-1, -1]
+
+        new_read_query_start = target_begin - 1
+        new_read_ref_start   = locus_start - flank + query_begin - 1
+
+        return [new_read_query_start, new_read_ref_start]
+        
+    else: # if its downstream (False)
+
+        # finding the downstream flank in the read
+        downstream = cooper.ref.fetch(read.chrom, locus_end, locus_end + flank)
+        alignment_score, target_begin, target_end, query_begin, query_end, sCigar = stripSW(Inputs(read.query_sequence, downstream), False)
+
+        # target_begin is the start of the alignment in the read
+        # query_begin  is the start of the alignment in the reference flank
+        # target_end   is the end of the alignment in the read
+        # query_end    is the end of the alignment in the reference flank
+
+        # if the downstream flank aligns to the already aligned region(by aligner), there is no expansion in the soft-clip, here target_begin is dummy
+        if target_begin <= read.query_end: return [-1, -1]
+
+        # reject read if less than 70% match with the reference flank sequence
+        if alignment_score < score_threshold: return [-1, -1]
+
+        new_read_query_end = target_end - 1
+        new_read_ref_end   = locus_end + query_end - 1
+
+        return [new_read_query_end, new_read_ref_end]
+
+
+def process_softclips(cooper, read, locus, dir):
+    """
+    process the soft-clipped regions of the read to process missed repeats
+    :param cooper: Cooper object containing reference and other data
+    :param read: pysam AlignedSegment object
+    :param softclip_loci: list of tuples (locus_start, locus_end) for the soft-clipped regions to be processed
+
+    :return: None
+             Modifies the read object in place
+             - updates the read cigar
+             - updates read reference start and end positions
+             - updates read query     start and end positions
+    """
+
+    # start_locus = sorted(softclip_loci, key=lambda x: x[0])[0]
+    # end_locus = sorted(softclip_loci, key=lambda x: x[1])[-1]
+    default_flank = 30
+
+    if dir == "left":
+        if read.ref_start > locus[0] + default_flank:
+            # detect the flank for the first upstream locus
+            new_read_query_start, new_read_ref_start = detect_flank(cooper, read, locus[0], locus[1], True)
+            if new_read_query_start == -1: return
+            unaligned_query = read.query_sequence[new_read_query_start:read.query_start]
+            unaligned_ref   = cooper.ref.fetch(read.chrom, new_read_ref_start, read.ref_start)
+            sub_cigar, alignment_score = nw_align(unaligned_query, unaligned_ref)
+            aligned_matches   = _match_lengths(read.cigarstring)
+            softclip_matches  = _match_lengths(sub_cigar)
+            if np.mean(softclip_matches)/np.mean(aligned_matches) >= 0.6 or np.mean(softclip_matches) >= 20:
+                sub_mdtag = generate_md_tag(sub_cigar, unaligned_ref, unaligned_query)
+                # update read positions and cigar
+                if read.has_tag('cs'):
+                    sub_cs_tag = cstag.call(sub_cigar, sub_mdtag, unaligned_query)
+                    read.cs_tag = join_cstags(sub_cs_tag, read.cs_tag)
+                if read.has_tag('MD') and read._read.has_tag('MD'):
+                    read.md_tag = join_mdtags(sub_mdtag, read.md_tag)
+
+                read.query_start = new_read_query_start
+                read.ref_start   = new_read_ref_start
+                if 'X' in read.cigarstring:
+                    if '=' in read.cigarstring: pass
+                    else: sub_cigar = sub_cigar.replace('=', 'M')
+                else:
+                    if 'M' in read.cigarstring:
+                        sub_cigar = sub_cigar.replace('=', 'M')
+                        sub_cigar = _collapse_mismatches(sub_cigar, 'M')
+                    elif '=' in read.cigarstring:
+                        sub_cigar = _collapse_mismatches(sub_cigar, '=')
+                read.cigarstring = join_cigars(sub_cigar, strip_softclip(read.cigarstring, 'left'))
+                if new_read_query_start > 0:
+                    read.cigarstring = f'{new_read_query_start}S'  + read.cigarstring
+                read.cigartuples = _cigar_tuples(read.cigarstring)
+                if _query_length(read.cigartuples) != len(read.query_sequence):
+                    raise ValueError("Query length after softclip processing does not match read sequence length.\n" +
+                                    f"Length from CIGAR: {(_query_length(read.cigartuples))}, " +
+                                    f"Read sequence length: {len(read.query_sequence)}")
+
+                if read.has_tag('MD') and not valid_md(read.md_tag, read.cigarstring):
+                    raise ValueError("MD tag is not consistent with CIGAR string after softclip processing.\n" +
+                                    f"MD stats: {md_stats(read.md_tag)}\nCIGAR stats: {cigar_stats(read.cigarstring)}")
+
+                return True
+
+    if dir == "right":
+        if read.ref_end < locus[1] - default_flank:
+            # detect the flank for the first downstream locus
+            new_read_query_end, new_read_ref_end = detect_flank(cooper, read, locus[0], locus[1], False)
+            if new_read_query_end == -1: return
+            unaligned_query = read.query_sequence[read.query_end:new_read_query_end]
+            unaligned_ref   = cooper.ref.fetch(read.chrom, read.ref_end, new_read_ref_end)
+            sub_cigar, alignment_score = nw_align(unaligned_query, unaligned_ref)
+            aligned_matches   = _match_lengths(read.cigarstring)
+            softclip_matches  = _match_lengths(sub_cigar)
+            if np.mean(softclip_matches)/np.mean(aligned_matches) >= 0.6 or np.mean(softclip_matches) >= 20:
+                sub_mdtag = generate_md_tag(sub_cigar, unaligned_ref, unaligned_query)
+                # update read positions and cigar
+                if read.has_tag('cs') and read._read.has_tag('cs'):
+                    sub_cs_tag = cstag.call(sub_cigar, sub_mdtag, unaligned_query)
+                    read.cs_tag = join_cstags(read.cs_tag, sub_cs_tag)
+                if read.has_tag('MD') and read._read.has_tag('MD'):
+                    read.md_tag = join_mdtags(read.md_tag, sub_mdtag)
+                    # read.md_tag = generate_md_tag(read.cigarstring, cooper.ref.fetch(read.chrom, read.ref_start, read.ref_end), read.query_sequence)
+
+                read.query_end = new_read_query_end
+                read.ref_end   = new_read_ref_end
+                if 'X' in read.cigarstring:
+                    if '=' in read.cigarstring: pass
+                    else: sub_cigar = sub_cigar.replace('=', 'M')
+                else:
+                    if 'M' in read.cigarstring:
+                        sub_cigar = sub_cigar.replace('=', 'M')
+                        sub_cigar = _collapse_mismatches(sub_cigar, 'M')
+                    elif '=' in read.cigarstring:
+                        sub_cigar = _collapse_mismatches(sub_cigar, '=')
+                read.cigarstring = join_cigars(strip_softclip(read.cigarstring, 'right'), sub_cigar)
+                if new_read_query_end < len(read.query_sequence):
+                    read.cigarstring += f'{len(read.query_sequence) - new_read_query_end}S'
+                read.cigartuples = _cigar_tuples(read.cigarstring)
+                if _query_length(read.cigartuples) != len(read.query_sequence):
+                    raise ValueError("Query length after softclip processing does not match read sequence length.\n" +
+                                    f"Length from CIGAR: {(_query_length(read.cigartuples))}, " +
+                                    f"Read sequence length: {len(read.query_sequence)}")
+
+                if _ref_length(read.cigartuples) != (read.ref_end - read.ref_start):
+                    raise ValueError("Reference length after softclip processing does not match read reference span.\n" +
+                                    f"Length from CIGAR: {(_ref_length(read.cigartuples))}, " +
+                                    f"Read reference span: {(read.ref_end - read.ref_start)}")
+
+                if read.has_tag('MD') and not valid_md(read.md_tag, read.cigarstring):
+                    raise ValueError("MD tag is not consistent with CIGAR string after softclip processing.\n" +
+                                    f"MD stats: {md_stats(read.md_tag)}\nCIGAR stats: {cigar_stats(read.cigarstring)}")
+
+                return True
+    return False
diff --git a/ATARVA/pyssw.py b/ATARVA/pyssw.py
new file mode 100644
index 0000000..52d2da3
--- /dev/null
+++ b/ATARVA/pyssw.py
@@ -0,0 +1,375 @@
+#!/usr/bin/env python
+"""
+Simple python wrapper for SSW library
+Please put the path of libssw.so into LD_LIBRARY_PATH or pass it explicitly as a parameter
+By Yongan Zhao (March 2016)
+Revised by Mengyao Zhao on 2022-May-23
+"""
+
+import sys
+import os.path as op
+import argparse as ap
+import ctypes as ct
+import timeit as ti
+import gzip
+import math
+import ATARVA.ssw_lib as ssw_lib
+
+
+def read(sFile):
+    """
+    read a sequence file
+    @param  sFile   sequence file
+    """
+    def read_one_fasta(f):
+        """
+        read a fasta file
+        @param  f   file handler
+        """
+        sId = ''
+        sSeq = ''
+        for l in f:
+            if l.startswith('>'):
+                if sSeq:
+                    yield sId, sSeq, ''
+                sId = l.strip()[1:].split()[0]
+                sSeq = ''
+            else:
+                sSeq += l.strip()
+
+        yield sId, sSeq, ''
+
+    def read_one_fastq(f):
+        """
+        read a fastq file
+        @param  f   file handler
+        """
+        sId = ''
+        sSeq = ''
+        s3 = ''
+        sQual = ''
+        for l in f:
+            sId = l.strip()[1:].split()[0]
+            sSeq = f.readline().strip()
+            s3 = f.readline().strip()
+            sQual = f.readline().strip()
+
+            yield sId, sSeq, sQual
+
+# test if fasta or fastq
+    bFasta = True
+    ext = op.splitext(sFile)[1][1:].strip().lower()
+    if ext == 'gz' or ext == 'gzip':
+        with gzip.open(sFile, 'r') as f:
+            l = f.readline()
+            if l.startswith('>'):
+                bFasta = True
+            elif l.startswith('@'):
+                bFasta = False
+            else:
+                sys.stderr.write('file format cannot be recognized\n')
+                sys.exit()
+    else:
+        with open(sFile, 'r') as f:
+            l = f.readline()
+            if l.startswith('>'):
+                bFasta = True
+            elif l.startswith('@'):
+                bFasta = False
+            else:
+                sys.stderr.write('file format cannot be recognized\n')
+                sys.exit()
+
+# read
+    if ext == 'gz' or ext == 'gzip':
+        with gzip.open(sFile, 'r') as f:
+            if bFasta == True:
+                for sId,sSeq,sQual in read_one_fasta(f):
+                    yield sId, sSeq, sQual
+            else:
+                for sId,sSeq,sQual in read_one_fastq(f):
+                    yield sId, sSeq, sQual
+    else:
+        with open(sFile, 'r') as f:
+            if bFasta == True:
+                for sId,sSeq,sQual in read_one_fasta(f):
+                    yield sId, sSeq, sQual
+            else:
+                for sId,sSeq,sQual in read_one_fastq(f):
+                    yield sId, sSeq, sQual
+
+
+def to_int(seq, lEle, dEle2Int):
+    """
+    translate a sequence into numbers
+    @param  seq   a sequence
+    """
+    num_decl = len(seq) * ct.c_int8
+    num = num_decl()
+    for i,ele in enumerate(seq):
+        try:
+            n = dEle2Int[ele]
+        except KeyError:
+            n = dEle2Int[lEle[-1]]
+        finally:
+            num[i] = n
+
+    return num
+
+
+def align_one(ssw, qProfile, rNum, nRLen, nOpen, nExt, nFlag, nMaskLen):
+    """
+    align one pair of sequences
+    @param  qProfile   query profile
+    @param  rNum   number array for reference
+    @param  nRLen   length of reference sequence
+    @param  nFlag   alignment flag
+    @param  nMaskLen   mask length
+    """
+    res = ssw.ssw_align(qProfile, rNum, ct.c_int32(nRLen), nOpen, nExt, nFlag, 0, 0, nMaskLen)
+
+    nScore = res.contents.nScore
+    nScore2 = res.contents.nScore2
+    nRefBeg = res.contents.nRefBeg
+    nRefEnd = res.contents.nRefEnd
+    nQryBeg = res.contents.nQryBeg
+    nQryEnd = res.contents.nQryEnd
+    nRefEnd2 = res.contents.nRefEnd2
+    lCigar = [res.contents.sCigar[idx] for idx in range(res.contents.nCigarLen)]
+    nCigarLen = res.contents.nCigarLen
+    ssw.align_destroy(res)
+
+    return (nScore, nScore2, nRefBeg, nRefEnd, nQryBeg, nQryEnd, nRefEnd2, nCigarLen, lCigar)
+
+
+def buildPath(q, r, nQryBeg, nRefBeg, lCigar):
+    """
+    build cigar string and align path based on cigar array returned by ssw_align
+    @param  q   query sequence
+    @param  r   reference sequence
+    @param  nQryBeg   begin position of query sequence
+    @param  nRefBeg   begin position of reference sequence
+    @param  lCigar   cigar array
+    """
+    sCigarInfo = 'MIDNSHP=X'
+    sCigar = ''
+    sQ = ''
+    sA = ''
+    sR = ''
+    nQOff = nQryBeg
+    nROff = nRefBeg
+    for x in lCigar:
+        n = x >> 4
+        m = x & 15
+        if m > 8:
+            c = 'M'
+        else:
+            c = sCigarInfo[m]
+        sCigar += str(n) + c
+
+        if c == 'M':
+            sQ += q[nQOff : nQOff+n]
+            sA += ''.join(['|' if q[nQOff+j] == r[nROff+j] else '*' for j in range(n)])
+            sR += r[nROff : nROff+n]
+            nQOff += n
+            nROff += n
+        elif c == 'I':
+            sQ += q[nQOff : nQOff+n]
+            sA += ' ' * n
+            sR += '-' * n
+            nQOff += n
+        elif c == 'D':
+            sQ += '-' * n
+            sA += ' ' * n
+            sR += r[nROff : nROff+n]
+            nROff += n
+    return sCigar, sQ, sA, sR
+
+
+def main(args):
+    lEle = []
+    dRc = {} 
+    dEle2Int = {}
+    dInt2Ele = {}
+    if False == args.bProtein:
+# init DNA score matrix
+        if not args.sMatrix:
+            lEle = ['A', 'C', 'G', 'T', 'N']
+            dRc = {'A':'T', 'C':'G', 'G':'C', 'T':'A', 'a':'T', 'c':'G', 'g':'C', 't':'A'} 
+            for i,ele in enumerate(lEle):
+                dEle2Int[ele] = i
+                dEle2Int[ele.lower()] = i
+                dInt2Ele[i] = ele
+            nEleNum = len(lEle)
+            lScore = [0 for i in range(nEleNum**2)]
+            for i in range(nEleNum-1):
+                for j in range(nEleNum-1):
+                    if lEle[i] == lEle[j]:
+                        lScore[i*nEleNum+j] = args.nMatch
+                    else:
+                        lScore[i*nEleNum+j] = -args.nMismatch
+        else:
+            lEle, dEle2Int, dInt2Ele, lScore = ssw_lib.read_matrix(args.sMatrix)
+    else:
+# load AA score matrix
+        if not args.sMatrix:
+            lEle = 'A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   X   *'.split()
+            for i,ele in enumerate(lEle):
+                dEle2Int[ele] = i
+                dEle2Int[ele.lower()] = i
+                dInt2Ele[i] = ele
+            nEleNum = len(lEle)
+            lScore = ssw_lib.lBlosum50
+        else:
+            # assume the format of the input score matrix is the same as that of http://www.ncbi.nlm.nih.gov/Class/FieldGuide/BLOSUM62.txt
+            lEle, dEle2Int, dInt2Ele, lScore = ssw_lib.read_matrix(args.sMatrix)
+
+    if args.bBest and args.bProtien:
+        sys.stderr.write('Reverse complement alignment is not available for protein sequences.\n')
+
+# translate score matrix to ctypes
+    mat = (len(lScore) * ct.c_int8) ()
+    mat[:] = lScore
+# set flag
+    nFlag = 0
+    if args.bPath:
+        nFlag = 2
+# print sam head
+    if args.bSam and args.bHeader and args.bPath:
+        print('@HD\tVN:1.4\tSO:queryname')
+        for sRId,sRSeq,_ in read(args.target):
+            print('@SQ\tSN:{}\tLN:{}'.format(sRId, len(sRSeq)))
+    elif args.bSam and not args.bPath:
+        sys.stderr.write('SAM format output is only available together with option -c.\n')
+        args.bSam = False
+
+    ssw = ssw_lib.CSsw(args.sLibPath)
+# iterate query sequence
+    for sQId,sQSeq,sQQual in read(args.query):
+# build query profile
+        qNum = to_int(sQSeq, lEle, dEle2Int)
+        qProfile = ssw.ssw_init(qNum, ct.c_int32(len(sQSeq)), mat, len(lEle), 2)
+# build rc query profile
+        if args.bBest and not args.bProtein:
+            sQRcSeq = ''.join([dRc[x] for x in sQSeq[::-1]])
+            qRcNum = to_int(sQRcSeq, lEle, dEle2Int)
+            qRcProfile = ssw.ssw_init(qRcNum, ct.c_int32(len(sQSeq)), mat, len(lEle), 2)
+# set mask len
+        nMaskLen = len(sQSeq) // 2
+        
+# iter target sequence
+        for sRId,sRSeq,_ in read(args.target):
+            rNum = to_int(sRSeq, lEle, dEle2Int)
+# format of res: (nScore, nScore2, nRefBeg, nRefEnd, nQryBeg, nQryEnd, nRefEnd2, nCigarLen, lCigar)
+            res = align_one(ssw, qProfile, rNum, len(sRSeq), args.nOpen, args.nExt, nFlag, nMaskLen)
+# align rc query
+            resRc = None
+            if args.bBest and not args.bProtein:
+                resRc = align_one(ssw, qRcProfile, rNum, len(sRSeq), args.nOpen, args.nExt, nFlag, nMaskLen)
+
+# build cigar and trace back path
+            strand = 0
+            if resRc == None or res[0] > resRc[0]:
+                resPrint = res
+                strand = 0
+                sCigar, sQ, sA, sR = buildPath(sQSeq, sRSeq, res[4], res[2], res[8])
+            else:
+                resPrint = resRc
+                strand = 1
+                sCigar, sQ, sA, sR = buildPath(sQRcSeq, sRSeq, resRc[4], resRc[2], resRc[8])
+
+# print results
+            if not args.bSam:
+                print('target_name: {}\nquery_name: {}\noptimal_alignment_score: {}\t'.format(sRId, sQId, resPrint[0])),
+                if resPrint[1] > 0:
+                    print('suboptimal_alignment_score: {}\t'.format(resPrint[1])),
+                if strand == 0:
+                    print('strand: +\t'),
+                else: 
+                    print('strand: -\t'),
+                if resPrint[2] + 1:
+                    print('target_begin: {}\t'.format(resPrint[2] + 1)),
+                print('target_end: {}\t'.format(resPrint[3] + 1)),
+                if resPrint[4] + 1:
+                    print('query_begin: {}\t'.format(resPrint[4] + 1)),
+                print('query_end: {}\n'.format(resPrint[5] + 1))
+                if resPrint[-2] > 0:
+                    n1 = 1 + resPrint[2]
+                    n2 = min(60,len(sR)) + resPrint[2] - sR.count('-',0,60)
+                    n3 = 1 + resPrint[4]
+                    n4 = min(60,len(sQ)) + resPrint[4] - sQ.count('-',0,60)
+                    for i in range(0, len(sQ), 60):
+                        print('Target:{:>8}\t{}\t{}'.format(n1, sR[i:i+60], n2))
+                        n1 = n2 + 1
+                        n2 = n2 + min(60,len(sR)-i-60) - sR.count('-',i+60,i+120)
+
+                        print('{: ^15}\t{}'.format('', sA[i:i+60]))
+
+                        print('Query:{:>9}\t{}\t{}\n'.format(n3, sQ[i:i+60], n4))
+                        n3 = n4 + 1
+                        n4 = n4 + min(60,len(sQ)-i-60) - sQ.count('-',i+60,i+120)
+            else:
+                print("{}\t".format(sQId)),
+                if resPrint[0] == 0:
+                    print("4\t*\t0\t255\t*\t*\t0\t0\t*\t*"),
+                else:
+                    mapq = int(-4.343 * math.log(1-abs(resPrint[0]-resPrint[1])/float(resPrint[0])))
+                    mapq = int(mapq + 4.99);
+                    if mapq >= 254:
+                        mapq = 254
+                    if strand == 1:
+                        print('16\t'),
+                    else:
+                        print('0\t'),
+                    print('{}\t{}\t{}\t'.format(sRId, resPrint[2]+1, mapq)),
+                    print(sCigar),
+                    print('\t*\t0\t0\t'),
+                    print(sQSeq[resPrint[4]:resPrint[5]+1]) if strand==0 else print(sQRcSeq[resPrint[4]:resPrint[5]+1]),
+                    print('\t'),
+                    if sQQual:
+                        if strand == 0:
+                            print(sQQual[resPrint[4]:resPrint[5]+1]),
+                        else:
+                            print(sQQual[-resPrint[4]-1:-resPrint[5]-1:-1])
+                    else:
+                        print('*'),
+
+                    print('\tAS:i:{}'.format(resPrint[0])),
+                    print('\tNM:i:{}\t'.format(len(sA)-sA.count('|'))),
+                    if resPrint[1] > 0:
+                        print('ZS:i:{}'.format(resPrint[1]))
+                    else:
+                        print
+
+
+        ssw.init_destroy(qProfile)
+        if args.bBest and not args.bProtein:
+            ssw.init_destroy(qRcProfile)
+
+
+if __name__ == '__main__':
+
+    parser = ap.ArgumentParser()
+    parser.add_argument('-l', '--sLibPath', default='./', help='path of libssw.so')
+    parser.add_argument('-m', '--nMatch', type=int, default=2, help='a positive integer as the score for a match in genome sequence alignment. [default: 2]')
+    parser.add_argument('-x', '--nMismatch', type=int, default=2, help='a positive integer as the score for a mismatch in genome sequence alignment. [default: 2]')
+    parser.add_argument('-o', '--nOpen', type=int, default=3, help='a positive integer as the penalty for the gap opening in genome sequence alignment. [default: 3]')
+    parser.add_argument('-e', '--nExt', type=int, default=1, help='a positive integer as the penalty for the gap extension in genome sequence alignment. [default: 1]')
+    parser.add_argument('-p', '--bProtein', action='store_true', help='Do protein sequence alignment. Without this option, pyssw will do genome sequence alignment. [default: False]')
+    parser.add_argument('-a', '--sMatrix', default='', help='a file for either Blosum or Pam weight matrix. [default: Blosum50]')
+    parser.add_argument('-c', '--bPath', action='store_true', help='Return the alignment path. [default: False]')
+    parser.add_argument('-f', '--nThr', default=0, help='a positive integer. Only output the alignments with the Smith-Waterman score >= N.')
+    parser.add_argument('-r', '--bBest', action='store_true', help='The best alignment will be picked between the original read alignment and the reverse complement read alignment. [default: False]')
+    parser.add_argument('-s', '--bSam', action='store_true', help='Output in SAM format. [default: no header]')
+    parser.add_argument('-header', '--bHeader', action='store_true', help='If -s is used, include header in SAM output.')
+    parser.add_argument('target', help='target file')
+    parser.add_argument('query', help='query file')
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit()
+    args = parser.parse_args()
+
+    t1 = ti.default_timer()
+    main(args)
+    t2 = ti.default_timer()
+    sys.stderr.write('CPU time: {} seconds\n'.format(t2 - t1))
diff --git a/ATARVA/readers.py b/ATARVA/readers.py
new file mode 100644
index 0000000..06f8aec
--- /dev/null
+++ b/ATARVA/readers.py
@@ -0,0 +1,111 @@
+import pysam
+import sys
+
+def fasta_check(path):
+    """
+    checks file existence and format of reference fasta
+
+    :param path: path to reference fasta file
+    """
+    try:
+        f = pysam.FastaFile(path)
+        f.close()
+    except (FileNotFoundError, ValueError, OSError) as e:
+        print(f"Error: {path} is not a valid FASTA file. {str(e)}")
+        sys.exit()
+    except Exception as e:
+        print("An unexpected error occurred:", str(e))
+        sys.exit()
+
+
+def bam_check(path, aln_format):
+    """
+    checks file existence and format of alignment file
+
+    :param path: path to alignment file
+    :param aln_format: format of the alignment file
+    """
+    try:
+        b = pysam.AlignmentFile(path, aln_format)
+        header = b.header
+        if 'HD' in header and 'SO' in header['HD']:
+            sort_order = header['HD']['SO']
+            if sort_order == 'coordinate':
+                pass
+                # print(f"Alignment file sort order: {sort_order}")
+            else:
+                print(f"Alignment file sort order: {sort_order}. It should be sorted by \'coordinate\'!!")
+                print(f"Use: samtools sort sorted_{path.split('/')[-1]} {path.split('/')[-1]}")
+                sys.exit()
+        else:
+            print("No sort order specified in the header.")
+            print(f"Use: samtools sort sorted_{path.split('/')[-1]} {path.split('/')[-1]}")
+            sys.exit()
+
+        b.close()
+    except (FileNotFoundError, ValueError, OSError) as e:
+        print(f"Error: {path} is not a valid alignment file. {str(e)}")
+        sys.exit()
+    except Exception as e:
+        print("An unexpected error occurred:", str(e))
+        sys.exit()
+
+
+def tabix_check(path):
+    """
+    checks file existence and format of tabix file
+
+    :param path: path to tabix file
+    """
+    try:
+        t = pysam.TabixFile(path)
+        t.close()
+    except (FileNotFoundError, ValueError, OSError) as e:
+        print(f"Error: {path} is not a valid tabix file. {str(e)}")
+        sys.exit()
+    except Exception as e:
+        print("An unexpected error occurred:", str(e))
+        sys.exit()
+
+
+def check_alnfile(bamfile, args):
+    """
+    check the alignment file for tags and determine the genotyping mode (SRS or LRS)
+
+    :param bamfile: path to the alignment file
+    :param args: command line arguments
+    :returns: srs (boolean) - True if SRS mode, False if LRS mode
+    """
+    n_reads = 0
+    aln_file = pysam.AlignmentFile(bamfile, args.aln_format)
+    for read in aln_file.fetch():
+        if (read.flag & 0X400) or (read.flag & 0X100): continue 
+        
+        n_reads += 1
+        if read.has_tag('cs'):
+            print("CS tag detected. Processing using CS tag...\n")
+            break
+        elif (read.cigarstring != None) and (('X' in read.cigarstring) or ('=' in read.cigarstring)):
+            print("CIGAR(X/=) tag detected. Processing using CIGAR(X/=) tag...\n")
+            break
+        elif read.has_tag('MD'):
+            print("MD tag detected. Processing using MD tag...")
+            print("Include CS tag or CIGAR tag with 'X/=' for faster processing.\n")
+            break
+        if n_reads > 100:
+            print(f"No tags detected in {bamfile.split('/')[-1]}. Processing without tags...")
+            print("Include the CS tag, MD tag, or CIGAR tag with 'X/=' for faster processing.\n")
+            break
+    aln_file.close()
+
+    srs = False
+    if (args.read_wise and args.locus_wise):
+        print('Error: Choose either Read-wise or Loci-wise genotyping mode!!')
+        sys.exit()
+    elif args.locus_wise:
+        srs = True
+        print('Processing in Loci-wise genotyping mode...')
+    else:
+        srs = False
+        print('Processing in Read-wise genotyping mode...')
+    return srs
diff --git a/ATARVA/realignment_utils.py b/ATARVA/realignment.py
similarity index 90%
rename from ATARVA/realignment_utils.py
rename to ATARVA/realignment.py
index 6b78a2a..ab16104 100644
--- a/ATARVA/realignment_utils.py
+++ b/ATARVA/realignment.py
@@ -1,5 +1,5 @@
-from Complete_Striped_Smith_Waterman_Library.src import pyssw
-from Complete_Striped_Smith_Waterman_Library.src import ssw_lib
+import ATARVA.pyssw as pyssw
+import ATARVA.ssw_lib as ssw_lib
 import ctypes as ct
 import os, sys
 
@@ -22,7 +22,7 @@ def restore_stderr(original_stderr):
 class Inputs:
     def __init__(self, target, query):
         # self.sLibPath = 'Complete_Striped_Smith_Waterman_Library/src'  # Set your libssw.so path
-        self.sLibPath = False #"./"  # Set your libssw.so path
+        self.sLibPath = False # Set your libssw.so path
         self.nMatch = 2
         self.nMismatch = 2
         self.nOpen = 3
@@ -37,7 +37,7 @@ def __init__(self, target, query):
         self.target = target  # Set your target file path
         self.query = query  # Set your query file path
 
-def stripSW(args):
+def stripSW(args, case):
     lEle = []
     dEle2Int = {}
     dInt2Ele = {}
@@ -56,7 +56,6 @@ def stripSW(args):
             else:
                 lScore[i*nEleNum+j] = -args.nMismatch
     
-    # print(so_path)
     ssw = ssw_lib.CSsw(args.sLibPath)
     
     sRSeq = args.target
@@ -78,4 +77,8 @@ def stripSW(args):
     else:
         res = pyssw.align_one(ssw, qProfile, rNum, len(sRSeq), args.nOpen, args.nExt, nFlag, nMaskLen)
     sCigar, sQ, sA, sR = pyssw.buildPath(sQSeq, sRSeq, res[4], res[2], res[8])
-    return sA, [res[4], res[5]]
+    
+    if case:
+        return sA, [res[4], res[5]]
+    else:
+        return [res[0], res[2], res[3], res[4], res[5], sCigar]
\ No newline at end of file
diff --git a/ATARVA/snp_utils.py b/ATARVA/snp_utils.py
index a6f93e7..d26b5f5 100644
--- a/ATARVA/snp_utils.py
+++ b/ATARVA/snp_utils.py
@@ -1,149 +1,382 @@
-def haplocluster_reads(snp_allelereads, ordered_snp_on_cov, read_indices, snpQ, snpC, snpR, phasingR):
+import numpy as np
 
-    threshold_range = [(0.3, 0.7),(0.25, 0.75),(0.2, 0.8)] # threshold values to get Significant_snps
-    for idx,range in enumerate(threshold_range):
 
-        final_haplos = ()
-        min_snp = -1
-        skip_point = 10
+def haplocluster_reads(cooper, locus_key):
+    """
+    cluster reads into haplotypes using SNP allele information.
 
-        r1 = range[0] # threshold value 1
-        r2 = range[1] # threshold value 2
+    :param cooper:      cooper object
+    :param locus_key:   locus key
+    :return:            minimum SNP position used for clustering, or -1 if clustering fails
+    """
 
-        filtered_significant_poses = {}
-        ordered_split_pos = []
-        for pos in ordered_snp_on_cov:
-            if snp_allelereads[pos]['cov'] < (0.6*len(read_indices)): break
-            if sum(r1 * sum(len(snp_allelereads[pos]['alleles'][nucs]) for nucs in snp_allelereads[pos]['alleles']) <= len(snp_allelereads[pos]['alleles'][nucs]) <= r2 * sum(len(snp_allelereads[pos]['alleles'][nucs]) for nucs in snp_allelereads[pos]['alleles']) for nucs in snp_allelereads[pos]['alleles']) >= 2:
-                ordered_split_pos.append(pos)
-                filtered_significant_poses[pos] = {'cov': snp_allelereads[pos]['cov'], 'alleles': snp_allelereads[pos]['alleles'], 'Qval': snp_allelereads[pos]['Qval']}
+    MIN_ALLELE_FRAC       = 0.2    # min fraction for allele quality calculation
+    THRESHOLD_RANGES      = [(0.3, 0.7), (0.25, 0.75), (0.2, 0.8)]
+    MIN_SNP_COVERAGE_FRAC = 0.6    # min fraction of reads a SNP must cover
 
+    locus = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
+    locus_cov  = locus_data.depth
 
-        if len(filtered_significant_poses) == 0:
-            if idx < 2: #level_split:
-                continue
-            else:
-                skip_point = 0
-                return [final_haplos, min_snp, skip_point, '', '', 0]
+    relevant_snps = set()    # SNPs relevant to the locus based on proximity
+    for rindex in locus_data.reads:
+        relevant_snps |= (cooper.cooper_read_data[rindex].snps)
+    relevant_snps = sorted(list(filter(lambda x: (x in cooper.cooper_snp_data) and (cooper.cooper_snp_data[x].cov >= 3) and
+                                                 (locus.start - cooper.args.snp_dist < x < locus.end + cooper.args.snp_dist),
+                            relevant_snps)))
 
-        final_haplos, status, min_snp, skip_point, chosen_snpQ, phased_read, snp_num = merge_snpreadsets(filtered_significant_poses, ordered_split_pos, read_indices, snpQ, snpC, snpR, phasingR) # calling the phasing function
-        if status: break
-        if idx == 2: #level_split:
+    relevant_snp_data = {}
+    alt_snp_cov = {}
+    for pos in relevant_snps:
+        qual_check = False
+        snp_data = cooper.cooper_snp_data[pos]
+        max_coverage = 0
+
+        passed_alts = set()
+        for alt in snp_data.sub:
+            alt_reads = snp_data.sub[alt].intersection(set(locus_data.reads))
+            alt_cov   = len(alt_reads)
+            if alt_cov == 0: continue
+            if alt_cov > max_coverage: max_coverage = alt_cov
+
+            avg_alt_qual = sum([snp_data.qual[idx] for idx in alt_reads])/alt_cov
+
+            if avg_alt_qual <= cooper.args.snp_qual:
+                qual_check = True
+                break
+            passed_alts.add(alt)
+        if max_coverage == 0 or qual_check:
+            continue
+        alt_snp_cov[pos] = max_coverage
+
+        relevant_snp_data[pos] = { 'cov': 0, 'alleles': {}, 'qual': {} }
+        for alt in passed_alts:
+            alt_reads = snp_data.sub[alt].intersection(set(locus_data.reads))
+            relevant_snp_data[pos]['cov']           += len(alt_reads)
+            relevant_snp_data[pos]['alleles'][alt]   = alt_reads
+            relevant_snp_data[pos]['qual'][alt]      = snp_data.qual
+        ref_reads = snp_data.ref.intersection(set(locus_data.reads))
+        if len(ref_reads) > 0:
+            relevant_snp_data[pos]['alleles']['r'] = ref_reads
+            relevant_snp_data[pos]['cov']         += len(ref_reads)
+
+    del_positions = list(filter(lambda x: relevant_snp_data[x]['cov'] < 5, relevant_snp_data.keys()))
+
+    for pos in del_positions:
+        del relevant_snp_data[pos]
+    ordered_snp_on_cov = sorted(relevant_snp_data.keys(), key = lambda item : alt_snp_cov[item], reverse = True)
+
+    sig_snp_data    = {}
+    ordered_sig_snps = []
+
+    for pos in ordered_snp_on_cov:
+        snp_data  = relevant_snp_data[pos]
+        pos_cov   = snp_data['cov']
+        if pos_cov < 0.6 * locus_cov: break
+        ordered_sig_snps.append(pos)
+        sig_snp_data[pos] = { 'cov': snp_data['cov'], 'alleles': snp_data['alleles'], 'qual': snp_data['qual'] }
+
+    min_snp_pos      = qvalue_phasing(cooper, locus, locus_data, sig_snp_data, ordered_sig_snps)
+    # for tier_idx, (lower_thresh, upper_thresh) in enumerate(THRESHOLD_RANGES):
+
+    #     sig_snp_data    = {}
+    #     ordered_sig_snps = []
+
+    #     for pos in ordered_snp_on_cov:
+    #         snp_data  = relevant_snp_data[pos]
+    #         pos_cov   = snp_data['cov']
+    #         if pos_cov < 0.6 * locus_cov: break
+
+    #         # count alleles where read fraction is within threshold bounds
+    #         balanced_alleles = sum(
+    #             lower_thresh * pos_cov <= len(reads) <= upper_thresh * pos_cov
+    #             for reads in snp_data['alleles'].values()
+    #         )
+
+    #         if balanced_alleles >= 2:
+    #             ordered_sig_snps.append(pos)
+    #             sig_snp_data[pos] = { 'cov': snp_data['cov'], 'alleles': snp_data['alleles'], 'qual': snp_data['qual'] }
+
+    #     if not ordered_sig_snps:
+    #         if tier_idx < 2: continue
+    #         return -1
+
+    #     min_snp_pos = merge_snpreadsets(cooper, locus_data, sig_snp_data, ordered_sig_snps)
+
+    #     if locus_data.is_genotyped or tier_idx == 2:
+    #         break
+
+    return min_snp_pos
+
+
+def merge_snpreadsets(cooper, locus_data, sig_snp_data, ordered_sig_snps):
+    """
+    merge SNP read sets to phase reads into two haplotype clusters.
+
+    :param cooper:              cooper object
+    :param locus_data:          locus data object
+    :param sig_snp_data:        significant SNP position data
+    :param ordered_sig_snps:    SNP positions ordered by significance
+    :return:                    [haplotypes, success, min_snp, skip_point, snp_quals, phased_reads, snp_count]
+    """
+    CLUSTER_JOIN_HIGH     = 0.7    # min intersection to join a cluster
+    CLUSTER_JOIN_LOW      = 0.05   # max intersection to confirm non-membership
+
+    del_positions = []
+    for pos in ordered_sig_snps:
+        remove_alts = []
+        for alt, reads in sig_snp_data[pos]['alleles'].items():
+            if len(reads) < 0.2 * sig_snp_data[pos]['cov']:
+                remove_alts.append(alt)
+        for alt in remove_alts:
+            del sig_snp_data[pos]['alleles'][alt]
+            if alt in sig_snp_data[pos]['qual']:
+                del sig_snp_data[pos]['qual'][alt]
+        if len(sig_snp_data[pos]['alleles']) < 2:
+            del_positions.append(pos)
+    for pos in del_positions:
+        del sig_snp_data[pos]
+        ordered_sig_snps.remove(pos)
+
+    snps     = ordered_sig_snps[:cooper.args.snp_count]
+
+    # --- compute quality values for top SNPs ---
+    snp_quals = [max(list(sig_snp_data[pos]['qual'].values())) for pos in snps]
+    snp_quals = ','.join(str(int(q)) for q in snp_quals)
+
+    # --- compute pairwise mismatch scores between SNPs ---
+    mismatch_scores = {}                  # {pos_a: {pos_b: mismatch_score}}
+
+    for i, pos_a in enumerate(snps):
+        if mismatch_scores and i == len(snps) - 1:
             break
+        mismatch_scores[pos_a] = {}
+        alleles_a = list(sig_snp_data[pos_a]['alleles'].values())
+
+        for pos_b in snps[i + 1:]:
+            score = sum(
+                min(len(reads_b & allele_a) for allele_a in alleles_a)
+                for reads_b in sig_snp_data[pos_b]['alleles'].values()
+            )
+            mismatch_scores[pos_a][pos_b] = score
 
-    return [final_haplos, min_snp, skip_point, chosen_snpQ, phased_read, snp_num]
-
-
-def merge_snpreadsets(Significant_poses, ordered_split_pos, read_indices, snpQ, snpC, snpR, phasingR):
-
-
-    skip_point = 10
-
-    sorted_alt_snp = ordered_split_pos[:snpC]
-    Alt_snp_Qval = []
-    for snps in sorted_alt_snp:
-        total_reads = Significant_poses[snps]['cov']
-        qvalue_list = set()
-        for nucs in Significant_poses[snps]['alleles']:
-            if (nucs!='r') and ((len(Significant_poses[snps]['alleles'][nucs])/total_reads) >= 0.2):
-                qvalue_list.add(sum([Significant_poses[snps]['Qval'][r_idx] for r_idx in Significant_poses[snps]['alleles'][nucs]]) / len(Significant_poses[snps]['alleles'][nucs]))
-
-        if qvalue_list != set():
-            Alt_snp_Qval.append(str(int(max(qvalue_list))))
-        
-        
-    chosen_snpQ = ','.join(Alt_snp_Qval)
-    phased_read = ''
-    snp_num = len(sorted_alt_snp)
-    
-    if len(sorted_alt_snp) == 0:
-        skip_point = 5
-        return [(), False, -1, skip_point, chosen_snpQ, phased_read, snp_num]
-    
-
-    sorted_filtered_dict = dict((snps,Significant_poses[snps]['alleles']) for snps in sorted_alt_snp)
-
-
-    #to remove the nucs with lower read contribution in sig_snps
-    for pos in sorted_filtered_dict:
-        del_nucs = []
-        tot_reads = sum([len(vals) for vals in sorted_filtered_dict[pos].values()]) # calculate the total read for that snp
-        if len(sorted_filtered_dict[pos]) == 2:
-            for nucs in sorted_filtered_dict[pos]:
-                if len(sorted_filtered_dict[pos][nucs])/tot_reads < snpR: del_nucs.append(nucs) # if the reads in 'nucs' have reads less than 25%, delete it
-        else:  # if snp has more than 2 'nucs' in it  # SUS!!!
-            for nucs in sorted_filtered_dict[pos]:
-                if len(sorted_filtered_dict[pos][nucs])/tot_reads < snpR: del_nucs.append(nucs) # if the reads in 'nucs' have reads less than 25%, delete it
-        for nucs in del_nucs:
-            del sorted_filtered_dict[pos][nucs]
-
-    # to remove pos with less than 2 nucs
-    del_pos = []
-    for pos in sorted_filtered_dict:
-        if len(sorted_filtered_dict[pos]) == 2:
-            pass
-        elif len(sorted_filtered_dict[pos]) < 2:
-            del_pos.append(pos)
-    for pos in del_pos:
-        del sorted_filtered_dict[pos]
-
-    if len(sorted_filtered_dict) == 0: # after removing snp based on their nuc's read coverage, if there are no snp left then go to next threshold range
-        skip_point = 1
-        return [(), False, -1, skip_point, chosen_snpQ, phased_read, snp_num]
-
-
-    # SNP Combination method 
-    poses = list(sorted_filtered_dict.keys()) # get only SNP coordinate
-    pos_cluster = {}
-    for idx in range(len(poses)): # Comparison starting from 1st snp to all other snp
-        if (pos_cluster!={}) and idx == len(poses)-1: break 
-        pos_cluster[poses[idx]] = {}
-        for pos in poses[idx + 1:]:
-            current_pos_values = list(sorted_filtered_dict[poses[idx]].values())  # [  {1,2,3,4,5},  {6,7,8,9,10} ]  nuc's read set for current Target SNP
-            mis_score = 0
-            for reads_set in sorted_filtered_dict[pos].values():  # [  {1,2,3,4,6},  {5,7,8,9,10}  ]  nuc's read set for Query SNP
-                similar_reads = set()
-                for i in range(len(current_pos_values)):
-                    intersection = reads_set & current_pos_values[i]  # intersection is calculated for each combination of 4 read sets
-                    similar_reads.add(len(intersection))   # taking the min value from a pairwise interection values
-                mis_score += min(similar_reads)
-            pos_cluster[poses[idx]][pos] = mis_score # pos_cluster = { 1023 : {1036 : 0, 1045 : 1, 1123 : 3,..},  1036 : { 1045: 1, 1123 : 2,..}, ..............}
-
-    significant_snps = []
-    for each_pos in pos_cluster:
-        if list(pos_cluster[each_pos].values()).count(0) >= 2: # check whether any of the pos_cluster have atleast 2 zeros in their mismatch scores
-            significant_snps.append(each_pos)
-            significant_snps.extend(sorted(pos_cluster[each_pos].keys(), key=lambda item: pos_cluster[each_pos][item])) # if yes take that pos_cluster and proceed for clustering
+    # --- select best SNPs for phasing ---
+    # prefer positions with at least 2 zero-mismatch neighbours
+    sig_snps = []
+    for pos, neighbours in mismatch_scores.items():
+        if sum(1 for s in neighbours.values() if s == 0) >= 2:
+            sig_snps.append(pos)
+            sig_snps.extend(sorted(neighbours, key=lambda p: neighbours[p]))
             break
-    if significant_snps == []: # if there are no pos_cluster with atleast 2 zeros in it
-        least_mismatches = {}
-        for each_pos in pos_cluster:
-            least_mismatches[each_pos] = sum(sorted(val for val in pos_cluster[each_pos].values())[:2]) # take sum of 1st 2 mismatch scores from sorted pos:mis_score and append in to 'least_mismatches' dictionary
-        current_pos = sorted(least_mismatches.keys(), key=lambda item: least_mismatches[item])[0] # now take the snp position with least score and proceed for clustering
-        significant_snps.append(current_pos)
-        significant_snps.extend(sorted(pos_cluster[current_pos].keys(), key=lambda item: pos_cluster[current_pos][item])) # [1023, 1036, 1045, 1123]
 
+    # fallback — pick position with lowest sum of two best scores
+    if not sig_snps:
+        best_pos = min(
+            mismatch_scores,
+            key=lambda p: sum(sorted(mismatch_scores[p].values())[:2])
+        )
+        sig_snps.append(best_pos)
+        sig_snps.extend(
+            sorted(mismatch_scores[best_pos], key=lambda p: mismatch_scores[best_pos][p])
+        )
 
+    # --- build final ordered SNP dict ---
+    final_snp_dict = {
+        pos: sig_snp_data[pos]['alleles']
+        for pos in sig_snps
+        if pos in sig_snp_data
+    }
+    min_snp_pos = min(final_snp_dict)
 
-    final_ordered_dict = {k: sorted_filtered_dict[k] for k in significant_snps if k in sorted_filtered_dict} # dict of 'final snp & its nucs : reads' for haplotyping, generated from 'significant_snps' list above
-    
-    min_snp = min(list(final_ordered_dict.keys()))
+    # --- cluster reads into two haplotypes ---
+    cluster1: set = set()
+    cluster2: set = set()
 
-    cluster1, cluster2 = set(), set()
-    for position_keys in final_ordered_dict: # clustering starts from the position of how its arranged in the dict, The 2 read_set will be two new haplotypes
-        for nuc_read in final_ordered_dict[position_keys].values():
+    for alleles in final_snp_dict.values():
+        for read_set in alleles.values():
             if not cluster1:
-                cluster1 |= nuc_read
+                cluster1 |= read_set
             elif not cluster2:
-                cluster2 |= nuc_read
-            elif (len(nuc_read & cluster1)>0.7*len(nuc_read)) and  (len(nuc_read & cluster2)<0.05*len(nuc_read)): # then successive read_set are joined based on their intersection percentage
-                cluster1 |= nuc_read
-            elif (len(nuc_read & cluster2)>0.7*len(nuc_read)) and  (len(nuc_read & cluster1)<0.05*len(nuc_read)):
-                cluster2 |= nuc_read
-
-    if ((len(cluster1)+len(cluster2)) >= phasingR*len(read_indices)): # after clustering the total reads in the both reads should be greater thn 50% of total supporting reads for that specific locus
-        phased_read = [len(cluster1),len(cluster2)]
-        return [(cluster1, cluster2), True, min_snp, skip_point, chosen_snpQ, phased_read, snp_num]
-    else:
-        skip_point = 2
-        return [(), False, -1, skip_point, chosen_snpQ, phased_read, snp_num]
\ No newline at end of file
+                cluster2 |= read_set
+            elif (len(read_set & cluster1) > CLUSTER_JOIN_HIGH * len(read_set) and
+                  len(read_set & cluster2) < CLUSTER_JOIN_LOW  * len(read_set)):
+                cluster1 |= read_set
+            elif (len(read_set & cluster2) > CLUSTER_JOIN_HIGH * len(read_set) and
+                  len(read_set & cluster1) < CLUSTER_JOIN_LOW  * len(read_set)):
+                cluster2 |= read_set
+
+    # --- validate phasing coverage ---
+    total_phased = len(cluster1) + len(cluster2)
+    if total_phased >= cooper.args.phasing_read * locus_data.depth:
+        locus_data.hap_read_sets      = (list(cluster1), list(cluster2))
+        locus_data.hap_alen_sets      = ([locus_data.read_alens[ridx][0] for ridx in cluster1], [locus_data.read_alens[ridx][0] for ridx in cluster2])
+        locus_data.is_genotyped       = True
+        locus_data.phase_mode         = 'snp'
+        locus_data.hap_category       = 0
+        locus_data.n_phasing_snps     = len(final_snp_dict)
+        locus_data.phasing_snp_quals  = snp_quals
+
+        return min_snp_pos
+
+    locus_data.is_genotyped    = False
+    locus_data.skip_code     = 1
+    return min_snp_pos
+
+
+def score_cluster_membership(cluster, read_idx, read_indices, score_matrix):
+    """
+    Function to score the membership of a read in a cluster based on its supporting reads.
+
+    Args:
+        cluster (set): Set of read indices in the cluster.
+        read_idx (int): Index of the read to be scored.
+        read_indices (set): Set of all read indices.
+        score_matrix (list): List of scores for each read pair.
+
+    Returns:
+        int: Score indicating the membership of the read in the cluster.
+    """
+    scores = []
+    for read in cluster:
+        i = read_indices.index(read)
+        j = read_indices.index(read_idx)
+        index = (i * len(read_indices)) + j
+        scores.append(score_matrix[index])
+    return sum(scores)/len(scores) if scores else 0
+
+
+def qvalue_phasing(cooper, locus, locus_data, sig_snp_data, ordered_sig_snps):
+    """
+    Function to cluster the reads based on SNPs and their supporting reads.
+
+    Args:
+        snp_allelereads (dict): Dictionary containing SNP positions and their alleles with supporting reads.
+        coverage_sorted_snps (list): List of SNP positions sorted by coverage.
+        read_indices (set): Set of read indices that support the SNPs.
+        args (Namespace): Command line arguments containing parameters like snpC, snpR, phasingR, snpQ.
+
+    Returns:
+        list: A list containing the final haplotypes, minimum SNP position, skip point,
+    """
+    del_positions = []
+    for pos in ordered_sig_snps:
+        remove_alts = []
+        for alt, reads in sig_snp_data[pos]['alleles'].items():
+            if len(reads) < 0.2 * sig_snp_data[pos]['cov']:
+                remove_alts.append(alt)
+        for alt in remove_alts:
+            del sig_snp_data[pos]['alleles'][alt]
+            if alt in sig_snp_data[pos]['qual']:
+                del sig_snp_data[pos]['qual'][alt]
+        if len(sig_snp_data[pos]['alleles']) < 2:
+            del_positions.append(pos)
+    for pos in del_positions:
+        del sig_snp_data[pos]
+        ordered_sig_snps.remove(pos)
+
+    if not ordered_sig_snps: return -1
+
+    if len(ordered_sig_snps) == 1:
+        max_alt_cov = max(len(reads) for reads in sig_snp_data[ordered_sig_snps[0]]['alleles'].values())
+        if max_alt_cov > 0.7 * locus_data.depth or max_alt_cov < 0.3 * locus_data.depth:
+            return -1
+
+    min_snp_pos = min(ordered_sig_snps)
+    sorted_reads = sorted(locus_data.reads)
+
+    # --- compute quality values for top SNPs ---
+    # snp_quals = [max(list([max(x) for x in sig_snp_data[pos]['qual'].values()])) for pos in ordered_sig_snps]
+    snp_quals = [max(list([max(list(x.values())) for x in sig_snp_data[pos]['qual'].values()])) for pos in ordered_sig_snps]
+    snp_quals = ','.join(str(int(q)) for q in snp_quals)
+
+    score_matrix = []
+    for i, read_a in enumerate(sorted_reads):
+        for j, read_b in enumerate(sorted_reads):
+            if read_a == read_b: score_matrix.append(0); continue
+            if j < i: score_matrix.append(score_matrix[j*len(sorted_reads) + i]); continue
+            
+            score = 0
+            for snp_pos in ordered_sig_snps:
+                allele_a = None; qual_a = None
+                allele_b = None; qual_b = None
+                for allele in sig_snp_data[snp_pos]['alleles']:
+                    if read_a in sig_snp_data[snp_pos]['alleles'][allele]:
+                        allele_a = allele
+                        if allele != 'r': qual_a = sig_snp_data[snp_pos]['qual'][allele][read_a]
+                        else: qual_a = cooper.cooper_read_data[read_a].mean_qual
+                    if read_b in sig_snp_data[snp_pos]['alleles'][allele]:
+                        allele_b = allele
+                        if allele != 'r': qual_b = sig_snp_data[snp_pos]['qual'][allele][read_b]
+                        else: qual_b = cooper.cooper_read_data[read_b].mean_qual
+                if allele_a is None or allele_b is None:
+                    pass
+                elif allele_a == allele_b:
+                    pass
+                elif qual_a < cooper.args.snp_qual or qual_b < cooper.args.snp_qual:
+                    pass
+                else:
+                    score -= (qual_a + qual_b)
+            score_matrix.append(score)
+
+    sorted_indices = np.argsort(score_matrix)
+
+    num_reads = len(sorted_reads)
+    cluster1 = set()
+    cluster2 = set()
+    phased_reads = set()
+    for itr, idx in enumerate(sorted_indices):
+        if score_matrix[idx] == 0: break
+        read_a = sorted_reads[idx // num_reads]
+        read_b = sorted_reads[idx % num_reads]
+
+        if read_a in phased_reads and read_b in phased_reads: continue
+
+        if itr == 0:
+            cluster1.add(read_a)
+            cluster2.add(read_b)
+            phased_reads.add(read_a); phased_reads.add(read_b)
+            continue
+        if read_b not in phased_reads:
+            score_b1 = score_cluster_membership(cluster1, read_b, sorted_reads, score_matrix)
+            score_b2 = score_cluster_membership(cluster2, read_b, sorted_reads, score_matrix)
+            if   score_b1 < score_b2:
+                cluster2.add(read_b)
+            elif score_b1 > score_b2:
+                cluster1.add(read_b)
+            phased_reads.add(read_b)
+        if read_a not in phased_reads:
+            score_a1 = score_cluster_membership(cluster1, read_a, sorted_reads, score_matrix)
+            score_a2 = score_cluster_membership(cluster2, read_a, sorted_reads, score_matrix)
+            if   score_a1 < score_a2:
+                cluster2.add(read_a)
+            elif score_a1 > score_a2:
+                cluster1.add(read_a)
+            phased_reads.add(read_a)
+
+        if len(phased_reads) == len(sorted_reads):
+            break
+
+    for read_a in sorted_reads:
+        if read_a not in phased_reads:
+            score_a1 = score_cluster_membership(cluster1, read_a, sorted_reads, score_matrix)
+            score_a2 = score_cluster_membership(cluster2, read_a, sorted_reads, score_matrix)
+            if   score_a1 < score_a2: cluster2.add(read_a)
+            elif score_a1 > score_a2: cluster1.add(read_a)
+            phased_reads.add(read_a)
+
+    # --- validate phasing coverage ---
+    total_phased = len(cluster1) + len(cluster2)
+    if total_phased >= cooper.args.phasing_read * locus_data.depth:
+        locus_data.hap_read_sets      = (list(cluster1), list(cluster2))
+        locus_data.hap_alen_sets      = ([locus_data.read_alens[ridx][0] for ridx in cluster1], [locus_data.read_alens[ridx][0] for ridx in cluster2])
+        locus_data.is_genotyped       = True
+        locus_data.phase_mode         = 'snp'
+        locus_data.hap_category       = 0
+        locus_data.n_phasing_snps     = len(sig_snp_data)
+        locus_data.phasing_snp_quals  = snp_quals
+
+        return min_snp_pos
+
+    locus_data.is_genotyped    = False
+    locus_data.skip_code     = 1
+    return min_snp_pos
\ No newline at end of file
diff --git a/ATARVA/somatic_utils.py b/ATARVA/somatic_utils.py
new file mode 100644
index 0000000..05f68d1
--- /dev/null
+++ b/ATARVA/somatic_utils.py
@@ -0,0 +1,82 @@
+import numpy as np
+from scipy.spatial.distance import pdist
+from scipy.cluster.hierarchy import linkage, dendrogram
+from ATARVA.sub_operation_utils import *
+
+seq_dict = {'A': [0, 0], 'C': [0, 1], 'G': [1, 0], 'T': [1, 1], 'N': [1, 1]}
+
+def correlation_clustering(read_seqs, read_indices, motif_size, global_loci_variations, locus_key):
+
+    seq_list = []
+    for read_id in read_indices:
+        seq_list.append(read_seqs[read_id][0])
+    # Convert sequence to bit representation using NumPy
+    # if variance is zero, paiwise distance will cause error
+    seq_len = [len(i) for i in seq_list]
+    bit_seqs = [np.concatenate([seq_dict.get(i, [1,1]) for i in seq]) if seq!='' else np.array([1,1]) for seq in seq_list]
+    # the array shouldn't contain same numbers eg [1,1,1,1], it should not have variance of '0' i.e why  'else np.array([1,1])' this is added, if the allele is a full deletion
+    # then padding will -1-1-1-1-1-1 giving 0 variance
+
+    max_seq_len = max(len(seq) for seq in bit_seqs) + 4
+    # if the lengthiest sequence is a monomer eg AAAAAAAAAAAAAAAAAAAAAAA, its variance is zero
+    # thats why extra '4' (any number of padding can be added) is added to the max length, so variance wont be zero
+
+    bit_matrix = np.array([np.pad(seq, (0, max_seq_len-len(seq)), constant_values = -1) for seq in bit_seqs], dtype=np.int8)
+    dist_matrix = pdist(bit_matrix, metric='correlation') # correlation formula is used for distance calculation
+    linkage_matrix = linkage(dist_matrix, method='complete') # complete method is used to get compact clusters
+
+    # 3rd col of Linkage has the distance values and 90th percentile is calculated to cut the dendrogram to get tight unique clusters
+    dist_percentile = np.percentile(linkage_matrix[:, 2], 90)
+
+    # Generating dendrogram details without plotting
+    den_detail = dendrogram(linkage_matrix, count_sort='descending', color_threshold=dist_percentile, no_plot=True)
+
+    # Grouping reads based on cluster colors
+    color = den_detail['leaves_color_list']
+    leaves = den_detail['leaves']
+    cluster_dict = {}
+    for idx, each_color in enumerate(color):
+        if each_color == 'C0': continue # skipping the outlier cluster
+        if each_color not in cluster_dict:
+            cluster_dict[each_color] = [read_indices[leaves[idx]]] # getting the read_id from leave_index of dendrogram
+        else:
+            cluster_dict[each_color].append(read_indices[leaves[idx]])
+
+    if len(cluster_dict)==0: # no valid clusters found
+        return [False, 6, {}]
+    
+    haplotypes = list(cluster_dict.values())
+
+    alt_seq_lens = set()
+    alt_seqs = set()
+
+    genotype_dict = {}
+    for hap_reads in haplotypes:
+
+        if len(hap_reads)<3: continue
+
+        ALT, allele_length, decomp_seq, repeativity = alt_sequence(read_seqs, hap_reads, True, motif_size) # true for amplicon, to check the repetitiveness in the sequence
+
+
+        # skip if the cluster has less reads and is not a repeat
+        if not repeativity:
+            continue
+
+        if allele_length in alt_seq_lens:
+            if ALT not in alt_seqs:
+                alt_seqs.add(ALT)
+            else:
+                continue
+        else:
+            alt_seq_lens.add(allele_length)
+            alt_seqs.add(ALT) 
+
+        ci = confidence_interval([len(read_seqs[read_id][0]) for read_id in hap_reads])
+        meth_info = methylation_calc(hap_reads, global_loci_variations, locus_key, ALT)
+        if allele_length not in genotype_dict:
+            genotype_dict[allele_length] = (ALT, ci, decomp_seq, len(hap_reads), meth_info)
+        else:
+            genotype_dict[str(allele_length)] = (ALT, ci, decomp_seq, len(hap_reads), meth_info)
+
+    del read_seqs, alt_seqs, alt_seq_lens, haplotypes, cluster_dict, bit_matrix, dist_matrix, linkage_matrix, den_detail
+    return [True, 10, genotype_dict]
diff --git a/ATARVA/ssw_lib.py b/ATARVA/ssw_lib.py
new file mode 100644
index 0000000..44a534b
--- /dev/null
+++ b/ATARVA/ssw_lib.py
@@ -0,0 +1,233 @@
+#!/usr/bin/env python
+"""
+Simple python wrapper for SSW library
+Please put the path of libssw.so into LD_LIBRARY_PATH or pass it explicitly as a parameter
+By Yongan Zhao (March 2016)
+Revised by Mengyao Zhao on 2022-May-19
+"""
+
+import sys
+import os.path as op
+import ctypes as ct
+
+if sys.platform.startswith('linux'):
+    sLibName = 'libssw.so'
+elif sys.platform == 'darwin':
+    sLibName = 'darwin_libssw.so'
+else:
+     raise OSError(f"Unsupported platform: {sys.platform}")
+
+sys.path.append(op.dirname(__file__))
+
+lBlosum50 = [
+	#  A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   X   *
+     	5, -2, -1, -2, -1, -1, -1,  0, -2, -1, -2, -1, -1, -3, -1,  1,  0, -3, -2,  0, -2, -1, -1, -5,	# A
+       -2,  7, -1, -2, -4,  1,  0, -3,  0, -4, -3,  3, -2, -3, -3, -1, -1, -3, -1, -3, -1,  0, -1, -5,	# R
+       -1, -1,  7,  2, -2,  0,  0,  0,  1, -3, -4,  0, -2, -4, -2,  1,  0, -4, -2, -3,  5,  0, -1, -5,	# N
+       -2, -2,  2,  8, -4,  0,  2, -1, -1, -4, -4, -1, -4, -5, -1,  0, -1, -5, -3, -4,  6,  1, -1, -5,	# D
+       -1, -4, -2, -4, 13, -3, -3, -3, -3, -2, -2, -3, -2, -2, -4, -1, -1, -5, -3, -1, -3, -3, -1, -5,	# C
+       -1,  1,  0,  0, -3,  7,  2, -2,  1, -3, -2,  2,  0, -4, -1,  0, -1, -1, -1, -3,  0,  4, -1, -5,	# Q
+       -1,  0,  0,  2, -3,  2,  6, -3,  0, -4, -3,  1, -2, -3, -1, -1, -1, -3, -2, -3,  1,  5, -1, -5,	# E
+     	0, -3,  0, -1, -3, -2, -3,  8, -2, -4, -4, -2, -3, -4, -2,  0, -2, -3, -3, -4, -1, -2, -1, -5,	# G
+       -2,  0,  1, -1, -3,  1,  0, -2, 10, -4, -3,  0, -1, -1, -2, -1, -2, -3,  2, -4,  0,  0, -1, -5,	# H
+       -1, -4, -3, -4, -2, -3, -4, -4, -4,  5,  2, -3,  2,  0, -3, -3, -1, -3, -1,  4, -4, -3, -1, -5,	# I
+       -2, -3, -4, -4, -2, -2, -3, -4, -3,  2,  5, -3,  3,  1, -4, -3, -1, -2, -1,  1, -4, -3, -1, -5,	# L
+       -1,  3,  0, -1, -3,  2,  1, -2,  0, -3, -3,  6, -2, -4, -1,  0, -1, -3, -2, -3,  0,  1, -1, -5,	# K
+       -1, -2, -2, -4, -2,  0, -2, -3, -1,  2,  3, -2,  7,  0, -3, -2, -1, -1,  0,  1, -3, -1, -1, -5,	# M
+       -3, -3, -4, -5, -2, -4, -3, -4, -1,  0,  1, -4,  0,  8, -4, -3, -2,  1,  4, -1, -4, -4, -1, -5,	# F
+       -1, -3, -2, -1, -4, -1, -1, -2, -2, -3, -4, -1, -3, -4, 10, -1, -1, -4, -3, -3, -2, -1, -1, -5,	# P
+     	1, -1,  1,  0, -1,  0, -1,  0, -1, -3, -3,  0, -2, -3, -1,  5,  2, -4, -2, -2,  0,  0, -1, -5,	# S
+    	0, -1,  0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1,  2,  5, -3, -2,  0,  0, -1, -1, -5, 	# T
+       -3, -3, -4, -5, -5, -1, -3, -3, -3, -3, -2, -3, -1,  1, -4, -4, -3, 15,  2, -3, -5, -2, -1, -5, 	# W
+       -2, -1, -2, -3, -3, -1, -2, -3,  2, -1, -1, -2,  0,  4, -3, -2, -2,  2,  8, -1, -3, -2, -1, -5, 	# Y
+     	0, -3, -3, -4, -1, -3, -3, -4, -4,  4,  1, -3,  1, -1, -3, -2,  0, -3, -1,  5, -3, -3, -1, -5, 	# V
+       -2, -1,  5,  6, -3,  0,  1, -1,  0, -4, -4,  0, -3, -4, -2,  0,  0, -5, -3, -3,  6,  1, -1, -5, 	# B
+       -1,  0,  0,  1, -3,  4,  5, -2,  0, -3, -3,  1, -1, -4, -1,  0, -1, -2, -2, -3,  1,  5, -1, -5, 	# Z
+       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -5, 	# X
+       -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,  1 	# *
+       ]
+
+
+
+class CAlignRes(ct.Structure):
+    """
+    @typedef	structure of the alignment result
+    @field	nScore	the best alignment score
+    @field	nScore2	sub-optimal alignment score
+    @field	nRefBeg	0-based best alignment beginning position on reference;	ref_begin1 = -1 when the best alignment beginning
+                                            position is not available
+    @field	nRefEnd	0-based best alignment ending position on reference
+    @field	nQryBeg	0-based best alignment beginning position on read; read_begin1 = -1 when the best alignment beginning
+                                            position is not available
+    @field	nQryEnd	0-based best alignment ending position on read
+    @field	nRefEnd2	0-based sub-optimal alignment ending position on read
+    @field	sCigar	best alignment cigar; stored the same as that in BAM format, high 28 bits: length, low 4 bits: M/I/D (0/1/2);
+                                    cigar = 0 when the best alignment path is not available
+    @field	nCigarLen	length of the cigar string; cigarLen = 0 when the best alignment path is not available
+    """
+    _fields_ = [('nScore', ct.c_uint16), 
+                ('nScore2', ct.c_uint16), 
+                ('nRefBeg', ct.c_int32), 
+                ('nRefEnd', ct.c_int32), 
+                ('nQryBeg', ct.c_int32), 
+                ('nQryEnd', ct.c_int32), 
+                ('nRefEnd2', ct.c_int32), 
+                ('sCigar', ct.POINTER(ct.c_uint32)), 
+                ('nCigarLen', ct.c_int32)] 
+
+
+
+class CProfile(ct.Structure):
+    """
+    @typedef	structure of the query profile
+    @field	pByte	byte array for profile
+    @field	pWord	word array for profile
+    @field	pRead	number array for read
+    @field	pMat	score matrix
+    @field	nReadLen	read length
+    @field	nN	edge length of score matrix
+    @field	nBias	bias
+    """
+    _fields_ = [('pByte', ct.POINTER(ct.c_int32)),
+                ('pWord', ct.POINTER(ct.c_int32)),
+                ('pRead', ct.POINTER(ct.c_int8)),
+                ('pMat', ct.POINTER(ct.c_int8)),
+                ('nReadLen', ct.c_int32),
+                ('nN', ct.c_int32),
+                ('nBias', ct.c_uint8)]
+
+
+
+class CSsw(object):
+    """
+    A class for libssw
+    """
+    def __init__(self, sLibPath):
+        """
+        init all para
+        @para   sLibpath    argparse object
+        """
+        
+        if sLibPath:
+# user does give the path explicitly
+            if not op.exists(op.join(sLibPath, sLibName)):
+                sys.stderr.write('libssw.so does not exist in the input path.')
+                sys.exit()
+            self.ssw = ct.cdll.LoadLibrary(op.join(sLibPath,sLibName))
+        else:
+# otherwise just search in PATH
+            bFound = False
+            for s in sys.path:
+                if op.exists(op.join(s,sLibName)):
+                    bFound = True
+                    self.ssw = ct.cdll.LoadLibrary(op.join(s,sLibName))
+            if bFound == False:
+                sys.stderr.write('libssw.so does not exist in PATH')
+                sys.exit()
+
+# init ssw_init
+        """
+	@function	Create the query profile using the query sequence.
+	@param	read	pointer to the query sequence; the query sequence needs to be numbers
+	@param	readLen	length of the query sequence
+	@param	mat	pointer to the substitution matrix; mat needs to be corresponding to the read sequence
+	@param	n	the square root of the number of elements in mat (mat has n*n elements)
+	@param	score_size	estimated Smith-Waterman score; if your estimated best alignment score is surely < 255 please set 0; if
+						your estimated best alignment score >= 255, please set 1; if you don't know, please set 2
+	@return	pointer to the query profile structure
+	@note	example for parameter read and mat:
+			If the query sequence is: ACGTATC, the sequence that read points to can be: 1234142
+			Then if the penalty for match is 2 and for mismatch is -2, the substitution matrix of parameter mat will be:
+			//A  C  G  T
+			  2 -2 -2 -2 //A
+			 -2  2 -2 -2 //C
+			 -2 -2  2 -2 //G
+			 -2 -2 -2  2 //T
+			mat is the pointer to the array {2, -2, -2, -2, -2, 2, -2, -2, -2, -2, 2, -2, -2, -2, -2, 2}
+        """
+        self.ssw_init = self.ssw.ssw_init
+        self.ssw_init.argtypes = [ct.POINTER(ct.c_int8), ct.c_int32, ct.POINTER(ct.c_int8), ct.c_int32, ct.c_int8]
+        self.ssw_init.restype = ct.POINTER(CProfile)
+# init init_destroy
+        """
+	@function	Release the memory allocated by function ssw_init.
+	@param	p	pointer to the query profile structure
+        """
+        self.init_destroy = self.ssw.init_destroy
+        self.init_destroy.argtypes = [ct.POINTER(CProfile)]
+        self.init_destroy.restype = None
+# init ssw_align
+        """
+!	@function	Do Striped Smith-Waterman alignment.
+	@param	prof	pointer to the query profile structure
+	@param	ref	pointer to the target sequence; the target sequence needs to be numbers and corresponding to the mat parameter of
+				function ssw_init
+	@param	refLen	length of the target sequence
+	@param	weight_gapO	the absolute value of gap open penalty
+	@param	weight_gapE	the absolute value of gap extension penalty
+	@param	flag	bitwise FLAG; (from high to low) bit 5: when setted as 1, function ssw_align will return the best alignment
+					beginning position; bit 6: when setted as 1, if (ref_end1 - ref_begin1 < filterd && read_end1 - read_begin1
+					< filterd), (whatever bit 5 is setted) the function will return the best alignment beginning position and
+					cigar; bit 7: when setted as 1, if the best alignment score >= filters, (whatever bit 5 is setted) the function
+  					will return the best alignment beginning position and cigar; bit 8: when setted as 1, (whatever bit 5, 6 or 7 is
+ 					setted) the function will always return the best alignment beginning position and cigar. When flag == 0, only
+					the optimal and sub-optimal scores and the optimal alignment ending position will be returned.
+	@param	filters	score filter: when bit 7 of flag is setted as 1 and bit 8 is setted as 0, filters will be used (Please check the
+ 					decription of the flag parameter for detailed usage.)
+	@param	filterd	distance filter: when bit 6 of flag is setted as 1 and bit 8 is setted as 0, filterd will be used (Please check
+					the decription of the flag parameter for detailed usage.)
+	@param	maskLen	The distance between the optimal and suboptimal alignment ending position >= maskLen. We suggest to use
+					readLen/2, if you don't have special concerns. Note: maskLen has to be >= 15, otherwise this function will NOT
+					return the suboptimal alignment information. Detailed description of maskLen: After locating the optimal
+					alignment ending position, the suboptimal alignment score can be heuristically found by checking the second
+					largest score in the array that contains the maximal score of each column of the SW matrix. In order to avoid
+					picking the scores that belong to the alignments sharing the partial best alignment, SSW C library masks the
+					reference loci nearby (mask length = maskLen) the best alignment ending position and locates the second largest
+					score from the unmasked elements.
+	@return	pointer to the alignment result structure
+	@note	Whatever the parameter flag is setted, this function will at least return the optimal and sub-optimal alignment score,
+			and the optimal alignment ending positions on target and query sequences. If both bit 6 and 7 of the flag are setted
+			while bit 8 is not, the function will return cigar only when both criteria are fulfilled. All returned positions are
+			0-based coordinate.
+        """
+        self.ssw_align = self.ssw.ssw_align
+        self.ssw_align.argtypes = [ct.c_void_p, ct.POINTER(ct.c_int8), ct.c_int32, ct.c_uint8, ct.c_uint8, ct.c_uint8, ct.c_uint16, ct.c_int32, ct.c_int32]
+        self.ssw_align.restype = ct.POINTER(CAlignRes)
+# init align_destroy
+        """
+	@function	Release the memory allocated by function ssw_align.
+	@param	a	pointer to the alignment result structure
+        """
+        self.align_destroy = self.ssw.align_destroy
+        self.align_destroy.argtypes = [ct.POINTER(CAlignRes)]
+        self.align_destroy.restype = None
+
+
+
+def read_matrix(sFile):
+    """
+    read a score matrix for either DNA or protein
+    assume the format of the input score matrix is the same as that of http://www.ncbi.nlm.nih.gov/Class/FieldGuide/BLOSUM62.txt
+
+    """
+    with open(args.sMatrix, 'r') as f:
+        for l in f:
+            if not l.startswith('#'):
+                break
+        lEle = l.strip().split()
+        dEle2Int = {}
+        dInt2Ele = {}
+        for i,ele in enumerate(lEle):
+            dEle2Int[ele] = i
+            dEle2Int[ele.lower()] = i
+            dInt2Ele[i] = ele
+        nEleNum = len(lEle)
+        lScore = []
+        for l in f:
+            lScore.extend([int(x) for x in l.strip().split()[1:]])
+
+        return lEle, dEle2Int, dInt2Ele, lScore
+
+
+if __name__ == '__main__':
+    pass
\ No newline at end of file
diff --git a/ATARVA/structures.py b/ATARVA/structures.py
new file mode 100644
index 0000000..3ec30a6
--- /dev/null
+++ b/ATARVA/structures.py
@@ -0,0 +1,175 @@
+from dataclasses import dataclass, field
+import pysam
+import numpy as np
+
+
+@dataclass(slots=True)
+class ReadLocusInfo:
+    halen: int  = 0
+    alen:  int  = 0
+    rlen:  int  = 0
+    seq:   list = field(default_factory=list)
+
+@dataclass(slots=True)
+class LocusInfo:
+    chrom:        str = ''
+    start:        int = 0
+    end:          int = 0
+    motif:        str = ''
+    length:       int = 0
+    motif_length: int = 0
+    name:         str = None
+
+    def __post_init__(self):
+        self.length       = self.end - self.start
+        self.motif_length = len(self.motif)
+
+@dataclass(slots=True)
+class ReadInfo:
+    start:       int   = 0
+    end:         int   = 0
+    snps:        set   = field(default_factory=set)
+    dels:        set   = field(default_factory=list)
+    no_snps:     set   = field(default_factory=set)
+    methylation: list  = field(default_factory=list)
+    mean_qual:   int   = 0
+    left_flank:  list  = field(default_factory=list)
+    right_flank: list  = field(default_factory=list)
+
+    def process_methylation_info(self, adj_fqs, adj_fqe, lower=0.2, upper=0.8):
+        """
+        Process methylation data for storing in locus data for genotyping and visualization
+        :param adj_fqs: adjusted flank start position of the read sequence supporting the locus after accounting for softclips and indels
+        :param adj_fqe: adjusted flank end position of the read sequence supporting the locus after accounting for softclips and indels
+        :param lower: lower threshold for methylation probability to consider as methylated
+        :param upper: upper threshold for methylation probability to consider as unmethylated
+        :return: tuple of (average methylation level, list of methylation positions, list of methylation encodings for visualization)
+        
+        Note: The methylation encoding is
+              -   -1 for uncertain methylation status (probability between lower and upper), 
+              -    1 for methylated (probability >= upper)
+              -    0 for unmethylated (probability <= lower)
+        """
+        read_mod_bases = self.methylation
+
+        meth_pos = []; meth_scores = []; meth_calls = [];
+        meth_count = meth_qual = 0
+        for pos, raw_prob in read_mod_bases:
+            if not (adj_fqs <= pos <= adj_fqe): continue
+            prob = raw_prob / 255
+            meth_pos.append(pos - adj_fqs)
+            meth_scores.append(raw_prob)
+            if lower < prob < upper:
+                meth_calls.append(-1)
+            else:
+                meth_count += 1
+                is_meth     = prob >= upper
+                meth_scores.append(raw_prob)
+                meth_calls.append(int(is_meth))
+                meth_qual  += is_meth
+
+        if meth_count: return (round(meth_qual / meth_count, 2), meth_pos, meth_scores, meth_calls)
+        else: return None
+
+
+@dataclass(slots=True)
+class LocusVariation:
+    reads:             list  = field(default_factory=list)  # list of all informative read indices for the locus
+    read_haplotags:    dict  = field(default_factory=dict)  # the haplotag assigned to each read in reads 
+    depth:             int   = 0                            # depth of the locus, updated when reads are subset for high coverage loci  
+    read_alens:        dict  = field(default_factory=dict)  # read index -> allele length dict for the reads supporting the locus
+    read_aseqs:        dict  = field(default_factory=dict)  # read index -> allele sequence dict for the reads supporting the locus, in the format (allele sequence, allele length) 
+    read_methylation:  dict  = field(default_factory=dict)  # read index -> (total methylation probability, methylation positions, methylation scores, methylation calls(0 or 1))
+    halen_frequency:   dict  = field(default_factory=dict)  # allele length -> count dict for the reads supporting the locus
+    alen_frequency:    dict  = field(default_factory=dict)  # allele length ignoring indels in homopolymers
+    allele_lengths:    list  = field(default_factory=list)  # list of allele lengths for the reads supporting the locus
+    min_read_qual:     float = float('inf')                            # minimum read quality among the reads supporting the locus
+    min_qual_read:     int   = None          # index of the read with minimum read quality among the reads supporting the locus
+
+    neighbors:        set   = field(default_factory=set)    # positions of neighbouring loci with shared reads
+
+    # updated when locus has high coverage and reads are subset
+    raw_depth:         int   = 0                            # original depth of the locus before subsetting
+    raw_reads:         list  = field(default_factory=list)  # original list of read indices supporting the locus before subsetting 
+    raw_haplotags:     dict  = field(default_factory=dict)  # original list of haplotags for the reads supporting the locus before subsetting
+
+    # data for genotyping
+    hap_read_sets:     tuple = ([], [])       # (hap1 read indices, hap2 read indices)
+    hap_alen_sets:     tuple = (None, None)   # (lengths in hap1 reads, lengths in hap2 reads)
+    hap_meth_data:     tuple = (None, None)   # (hap1 meth data, hap2 meth data) methylation data for the genotype call, in the format (average methylation level, number of reads with methylation info, encoded methylation string for visualization)
+    is_genotyped:      int   = 0              # whether the locus was genotyped successfully
+    hap_category:      int   = None           # 1: homozygous, 2: ambiguous, 3: haplotag
+    gt_depth:          int   = 0              # reads used for haplogrouping after filtering out
+    gt_aseqs:          tuple = (None, None)   # (allele1, allele2) allele sequences for the genotype call
+    gt_alens:          tuple = (None, None)   # (alen1, alen2) allele lengths for the genotype call
+    gt_arange:         tuple = (None, None)   # allele length range for the genotype call, in the format 'lower1-upper1,lower2-upper2'
+    gt_decomp_seqs:    tuple = (None, None)   # (decomposed allele1, decomposed allele2) motif decomposition of the allele sequences
+    is_phased:         bool  = False          # whether haplotagging was successful
+    skip_code:         int   = 10             # whether genotyping failed for the locus
+    n_phasing_snps:    int   = 0              # number of SNPs used for phasing, if phased by SNPs
+    phasing_snp_quals: str   = ''             # comma-separated string of SNP quality scores, if phased by SNPs
+    phase_mode:        str   = None           # 0: phased by SNPs, 1: phased by length    
+
+
+@dataclass(slots=True)
+class SNP:
+    cov:  int   = 0
+    sub:  dict  = field(default_factory=dict)
+    qual: dict  = field(default_factory=dict)
+    ref:  set   = field(default_factory=set)
+
+
+class ExtendedRead(pysam.AlignedSegment):
+
+    @classmethod
+    def from_read(cls, read: pysam.AlignedSegment):
+        """Factory method to create ExtendedRead from a pysam read"""
+        ext        = cls()
+        ext._read  = read
+
+        # copy core pysam attributes
+        ext.query_name                = read.query_name
+        ext.query_sequence            = read.query_sequence
+        ext.flag                      = read.flag
+        ext.reference_id              = read.reference_id
+        ext.reference_start           = read.reference_start
+        ext.ref_start                 = read.reference_start
+        ext.ref_end                   = read.reference_end
+        ext.query_start               = read.query_alignment_start
+        ext.query_end                 = read.query_alignment_end
+        ext.mapping_quality           = read.mapping_quality
+        ext.cigar                     = read.cigar
+        ext.next_reference_id         = read.next_reference_id
+        ext.next_reference_start      = read.next_reference_start
+        ext.template_length           = read.template_length
+        ext.query_qualities           = read.query_qualities
+        ext.tags                      = read.tags
+        ext.has_tag                   = read.has_tag
+        if read.has_tag('cs'):
+            ext.cs_tag            = read.cs_tag
+        if read.has_tag('MD'):
+            ext.md_tag            = read.get_tag('MD')
+
+        # custom attributes
+        ext.index                  = None
+        ext.chrom                  = read.reference_name
+        ext.ref_start              = read.reference_start
+        ext.ref_end                = read.reference_end
+        ext.query_start            = read.query_alignment_start
+        ext.query_end              = read.query_alignment_end
+        ext.sequence               = read.query_sequence
+        ext.mean_qual              = int(sum(read.query_qualities)/len(read.query_qualities)) if read.query_qualities else 0
+        ext.loci                   = []
+        ext.loci_coords            = []
+        ext.loci_keys              = []
+        ext.loci_data              = dict()
+        ext.homopolymer_positions  = dict()
+        ext.left_flanks            = []
+        ext.right_flanks           = []
+        ext.haplotag               = [False, None]
+
+        ext.methyl_start           = 0
+        ext.methyl_end             = 0
+        ext.methylation_calls      = []     # list of tuples (position, probability) for methylation calls in the read
+
+        return ext
diff --git a/ATARVA/sub_operation_utils.py b/ATARVA/sub_operation_utils.py
new file mode 100644
index 0000000..682a708
--- /dev/null
+++ b/ATARVA/sub_operation_utils.py
@@ -0,0 +1,251 @@
+import string, sys
+import numpy as np
+from scipy import stats
+
+from ATARVA.consensus import *
+from ATARVA.decompose import motif_decomposition
+
+methviz_tag = False
+def set_methviz_tag(value):
+    global methviz_tag
+    methviz_tag = value
+
+
+# base64 encodings
+BASE64_CHARS = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+//'
+NO_MATCH  = -2   # code for unmatched position
+AMBIGUOUS = -1   # code for ambiguous methylation call
+METH_ENCODING = { NO_MATCH  : '*',   # error / missing call
+                  AMBIGUOUS : '-' }   # ambiguous call
+
+
+def mm_tag_extract(read, mod_probs):
+    """
+    record the positions with methylation calls
+    
+    :param read: pysam AlignedSegment object
+    :param mod_probs: list of tuples with modified base positions and their respective probabilities
+    :param meth_cutoff: score cutoff for calling methylation
+    :param frwd_strand: boolean value for strand state; forward = True, reverse = False
+    :return: none; the methylation positions are recorded in the read.methylation_calls attribute
+    """
+
+    last_index   = len(read.query_sequence) - 1
+    frwd_strand  = read.is_forward
+    methyl_start = read.methyl_start
+    methyl_end   = read.methyl_end
+    methylation_calls = read.methylation_calls
+    qseq = read.query_sequence
+    if (methyl_start != None) and (methyl_end != None):
+        for pos, prob in mod_probs:
+            meth_chunk_start = pos if frwd_strand else pos - 1 # to check the meth context, start index
+            if methyl_start <= pos <= methyl_end:
+                if (pos + 1 <= last_index) and (qseq[meth_chunk_start : meth_chunk_start + 2]=='CG'):
+                    methylation_calls.append((pos, prob))
+
+
+def align_cg_positions(consensus_cg_pos, read_cg_pos):
+    """
+    Align CpG positions from a read to consensus CpG positions.
+    Returns indices into read_cg_pos that best match each consensus position.
+    -2 indicates no match found for a consensus position.
+
+    :param consensus_cg_pos: CpG positions in the consensus sequence
+    :param read_cg_pos:      CpG positions in the read sequence
+    :return:                 list of read indices aligned to each consensus position
+    """
+    consensus_gaps  = np.diff(consensus_cg_pos, prepend=0)
+    read_gaps       = np.diff(read_cg_pos,       prepend=0)
+
+    n_read_gaps     = len(read_gaps)
+    read_exceeds    = n_read_gaps >= len(consensus_cg_pos)  # read has more CGs than consensus
+
+    aligned_read_idx  = []   # matched read index for each consensus position
+    read_cursor       = 0    # current position in read_gaps
+    gap_remainder     = 0    # carry-over gap difference between iterations
+
+    TOLERANCE         = 4    # max bp tolerance for initial position matching
+    LAST_POS_WINDOW   = 10   # max bp tolerance for last position matching
+    NO_MATCH          = -2   # sentinel for unmatched consensus position
+
+    for cons_idx, cons_gap in enumerate(consensus_gaps):
+        n_matched_before = len(aligned_read_idx)
+
+        # --- find optimal start position ---
+        if read_exceeds and cons_idx == 0 and read_cursor == 0:
+            gap_diff = read_gaps[read_cursor] - cons_gap
+
+            if abs(gap_diff) < TOLERANCE:
+                # gaps are close enough — direct match
+                aligned_read_idx.append(cons_idx)
+                gap_remainder = gap_diff
+                read_cursor  += 1
+            else:
+                # slide read positions to find better alignment start
+                slide_dist    = consensus_cg_pos[cons_idx] - read_cg_pos[cons_idx]
+                shifted_pos   = read_cg_pos - slide_dist
+
+                dist_original = np.abs(consensus_cg_pos[cons_idx] - read_cg_pos)
+                dist_shifted  = np.abs(consensus_cg_pos[cons_idx] - shifted_pos)
+
+                # pick whichever alignment has lower total distance
+                if dist_original.sum() <= dist_shifted.sum():
+                    read_cursor = int(np.argmin(dist_original))
+                else:
+                    read_cursor = int(np.argmin(dist_shifted))
+
+                aligned_read_idx.append(read_cursor)
+                read_cursor += 1
+
+            continue
+
+        # --- scan read gaps to find best match for current consensus gap ---
+        cumulative_gap = gap_remainder
+        min_diffs      = [100_000]
+
+        while read_cursor < n_read_gaps:
+            cumulative_gap += read_gaps[read_cursor]
+            current_diff    = abs(cumulative_gap - cons_gap)
+
+            # diff increasing — previous position was better match
+            if current_diff > min(min_diffs):
+                best_cursor = read_cursor - 1
+                if best_cursor not in aligned_read_idx:
+                    aligned_read_idx.append(best_cursor)
+                    gap_remainder = (cumulative_gap - read_gaps[read_cursor]) - cons_gap
+                break
+
+            # last position check
+            is_last     = read_cursor + 1 == n_read_gaps
+            last_in_win = abs(cons_gap - read_gaps[read_cursor]) < LAST_POS_WINDOW
+            if is_last and last_in_win:
+                if read_cursor not in aligned_read_idx:
+                    aligned_read_idx.append(read_cursor)
+                read_cursor += 1
+                break
+
+            min_diffs.append(current_diff)
+            read_cursor += 1
+
+        # --- no match found for this consensus position ---
+        if len(aligned_read_idx) == n_matched_before:
+            aligned_read_idx.append(NO_MATCH)
+
+    return aligned_read_idx
+
+
+def encode_methylation(call_matrix, pos_matrix, consensus_cgs):
+    """
+    encode methylation scores at consensus CpG positions into a compact string for visualization
+
+    :param call_matrix: list of lists with methylation calls for each read at their respective CpG positions
+    :param pos_matrix: list of lists with read CpG positions aligned to consensus CpG
+    :param consensus_cgs: list of CpG positions in the consensus sequence
+    :return: encoded methylation string where each character represents the consensus CpG position and its methylation status across reads
+    """
+
+    # --- align each read's CG positions to consensus ---
+    aligned_pos_matrix = [
+        align_cg_positions(consensus_cgs, np.array(read_cgs))
+        for read_cgs in pos_matrix
+    ]
+
+    # --- build score matrix using aligned positions ---
+    aligned_score_matrix = [
+        [meth_calls[pos] if pos != NO_MATCH else NO_MATCH
+         for pos in aligned_pos]
+        for meth_calls, aligned_pos in zip(call_matrix, aligned_pos_matrix)
+    ]
+
+    # --- encode each consensus CG position ---
+    encoded_meth = []
+    for col in zip(*aligned_score_matrix):
+        col_array = np.array(col)
+        # mode      = stats.mode(col_array, keepdims=True).mode[0]
+        values, counts = np.unique(col_array, return_counts=True)
+        mode = values[np.argmax(counts)]
+
+        if mode in METH_ENCODING:
+            encoded_meth.append(METH_ENCODING[mode])
+            continue
+
+        # filter sentinels and compute mean
+        avg_base_meth = np.mean(col_array[(col_array != AMBIGUOUS) & (col_array != NO_MATCH)])
+        base64_scaled = round(avg_base_meth * 63)    # scale to 0-64
+        encoded_meth.append(BASE64_CHARS[base64_scaled])
+
+    return ''.join(encoded_meth)
+
+
+def calculate_methylation(read_indices, read_methylation, consensus_seq):
+    """
+    calculate the methylation level at CG positions for a haplogroup based on the consensus sequence of the haplogroup
+
+    :param read_indices: list of read ids supporting the locus
+    :param methyl_probabilities: list of tuples with modified base positions and their respective probabilities for each read
+    :param consensus_seq: the consensus sequence
+    :return: average methylation level, number of reads with methylation information, encrypted methylation string for visualization
+    """
+
+    arr  = np.frombuffer(consensus_seq.upper().encode(), dtype=np.uint8)
+    c_mask = arr[:-1] == ord('C')
+    g_mask = arr[1:]  == ord('G')
+    cg_positions = np.where(c_mask & g_mask)[0]
+
+    if cg_positions.size == 0:
+        return [None, None, None]
+
+    methyl_nreads       = 0
+    haplotype_avgmeth   = 0
+    encoded_methylation = None
+    call_matrix = []
+    pos_matrix  = []
+    for read_index in read_indices:
+        if read_methylation[read_index] is None: continue
+        avg_read_meth, positions, meth_scores, meth_calls = read_methylation[read_index]
+        methyl_nreads += 1
+        haplotype_avgmeth += avg_read_meth
+        # for meth visualization
+        if methviz_tag:
+            pos_matrix.append(positions)
+            call_matrix.append(meth_calls)
+
+    if methyl_nreads > 0:
+        if methviz_tag:
+            encoded_methylation = encode_methylation(call_matrix, pos_matrix, cg_positions)
+        return [round(haplotype_avgmeth/methyl_nreads, 2), methyl_nreads, encoded_methylation]
+    else:
+        return [None, None, None]
+
+
+def alt_sequence(read_alleles, hap_reads, motif_size):
+    """
+    generates alt sequence and reports characteristics
+
+    :param read_alleles: dict with read_id as key and allele sequence as value
+    :param hap_reads: list of read_ids belonging to the haplotype cluster
+    :param motif_size: size of the motif for checking repetitiveness
+    :return: ALT, allele_length, decomposed_seq, repetitive: alt sequence, its length, motif decomposition and repetitiveness status
+    """
+
+    # wouldn't most of the reads say deleted and only one read has some sequence ???
+    ALT = ''
+    seqs = [seq for seq in [read_alleles[read_id][0] for read_id in hap_reads] if seq!='']
+    if seqs:
+        length_counter = {}
+        for seq in seqs:
+            try: length_counter[len(seq)] += 1
+            except KeyError: length_counter[len(seq)] = 1
+        seqs = sorted(seqs, key=lambda x: (-length_counter[len(x)], len(x), x))  # sort by frequency of length then length
+        ALT = consensus_seq_poa(seqs)
+        allele_length = len(ALT)
+    else:
+        ALT = '<DEL>'
+        allele_length = 0
+
+    decomposed_seq = ''
+    is_repetitive = True
+    if allele_length and (motif_size <= 10):
+        decomposed_seq, nonrep_fraction = motif_decomposition(ALT, motif_size)
+        if nonrep_fraction > 0.30: is_repetitive = False
+    return [ALT, allele_length, decomposed_seq, is_repetitive]
diff --git a/ATARVA/tamatr.py b/ATARVA/tamatr.py
new file mode 100644
index 0000000..ff8849e
--- /dev/null
+++ b/ATARVA/tamatr.py
@@ -0,0 +1,428 @@
+import sys, os
+import pysam
+import threading
+import polars as pl
+from functools import reduce
+
+def processor(process_df, outfile, tidx, each_thread, total_samples):
+    # print('starting process = ', each_thread)
+    #print(process_df.columns)
+    out = open(f'{outfile}_reader{tidx}_processor{each_thread}.vcf', 'w')
+    for row_dict in process_df.iter_rows(named=True):
+        genotyped_samples = 0
+        sample_wise_full_gt = []
+        ALT = []
+        alt_seq_lens = []
+        alt_seq_count = {}
+        for file_id in range(total_samples):
+            current_sample = row_dict[f's{file_id}']
+            if current_sample:
+                splited_sample = current_sample.split(':')
+                individual_sample_gt = splited_sample[1]
+            else:
+                sample_wise_full_gt.append('.:.:.:.:.:.:.:.:.')
+                continue
+            if individual_sample_gt=='.':
+                sample_wise_full_gt.append('.:.:.:.:.:.:.:.:.')
+            else:
+                genotyped_samples += 1
+                GT = []
+                alt_seqs = splited_sample[0].split(',') if splited_sample[0]!='.' else ""
+                seq_lens = [0 if i=='<DEL>' else len(i) for i in alt_seqs]
+                for idx,lens in enumerate(seq_lens):
+                    if lens in alt_seq_lens:
+                        alt_seq_count[lens] += 1 # count of that alt allele
+                        GT.append(str(alt_seq_lens.index(lens) + 1))
+                    else:
+                        ALT.append(alt_seqs[idx])
+                        alt_seq_lens.append(lens)
+                        alt_seq_count[lens] = 1 # initialize count of that alt allele
+                        GT.append(str(len(alt_seq_lens)))
+                alt_count = len(GT)
+                if len(individual_sample_gt) > 1: # autosomes
+                    phaser = individual_sample_gt[1] # either '/' or '|'
+                    sep_gt = individual_sample_gt.split(phaser) # separated genotype
+                            
+                    if alt_count==2: # if there are two alt alleles
+                        new_GT = phaser.join(GT)
+                    elif alt_count == 1: # if there is only one alt alleles
+                        the_single_gt = GT[0]
+                        if len(set(sep_gt)) == 2: # if it is heterozyous
+                            new_GT = phaser.join(['0', the_single_gt])
+                        else: # if it is homozygous
+                            new_GT = phaser.join([the_single_gt, the_single_gt])
+                    else:
+                        new_GT = '0'+phaser+'0' 
+                else: # Sex chromosomes
+                    if alt_count==1:
+                        new_GT = str(GT[0])
+                    else:
+                        new_GT = '0'                        
+
+                splited_sample[1] = new_GT
+                sample_wise_full_gt.append(':'.join(splited_sample[1:]))
+        if genotyped_samples:
+            pass
+        else:
+            continue
+        if alt_seq_lens:
+            AC = []
+            for i in alt_seq_lens:
+                AC.append(str(alt_seq_count[i]))
+            AC = ','.join(AC)
+        else:
+            AC = '0'
+        AN = str(genotyped_samples * 2)
+        info = 'AC='+AC+';AN='+AN+';' + row_dict['i']
+        ref_seq = row_dict['r']
+        start = row_dict['s']
+        chrom = row_dict['c']
+        filter = '.'
+        id = '.'
+        q = '.'
+        alt = ','.join(ALT) if ALT else '.'
+        format = 'GT:AL:AR:SD:DP:SN:SQ:MM:MR'
+        #sample = '\t'.join(sample_wise_full_gt)
+
+        repeat_info = [chrom, start, id, ref_seq, alt, q, filter, info, format, *sample_wise_full_gt]
+        del sample_wise_full_gt
+        tot_tabs = len(repeat_info)
+        chunk_size = 100
+        for i in range(0, tot_tabs, chunk_size):
+            chunk = repeat_info[i:i + chunk_size]
+            out.write("\t".join(map(str, chunk)))
+            if i<tot_tabs-1:
+                out.write("\t")
+        out.write("\n")
+        #out.write("\t".join(map(str, repeat_info)) + "\n")
+        del repeat_info
+    out.close()
+    # print('DONE Processing....')
+
+def reader(outfile, bedfile, ref, vcfs, contigs, tidx, process_thread):
+
+    total_samples = len(vcfs)
+    #print("total_samples = ", total_samples)
+    tbx = pysam.TabixFile(bedfile)
+    ref_file = pysam.FastaFile(ref)
+    vcf_instance = []
+    for each_vcf in vcfs:
+        vcf_instance.append(pysam.TabixFile(each_vcf))
+    #print(len(vcf_instance))
+    if tidx!=-1: # multi thread
+        if tidx==0: # first process
+            vcf_names = [file_path.split("/")[-1].split('.')[0] for file_path in vcfs]
+            out = open(f'{outfile}.vcf', 'w')
+            vcf_writer(out, vcf_names, vcfs[0])
+        else:
+            out = open(f'{outfile}_thread_{tidx}.vcf', 'w')
+    else: # single thread
+        vcf_names = [file_path.split("/")[-1].split('.')[0] for file_path in vcfs]
+        out = open(f'{outfile}.vcf', 'w')
+        vcf_writer(out, vcf_names, vcfs[0])
+
+
+    thread_pool = list()
+    print('Reader thread = ', tidx)
+    print(f'Inside reader{tidx} = length of contig = {len(contigs)}')
+    for contig in contigs:
+        
+        Chrom, Start, End = contig
+        # print("\nReading new block............")
+        frames = []
+        base_frame = pl.DataFrame().lazy()
+        parquet_batch = 0
+        file_count = 0
+        for file_id,file in enumerate(vcf_instance):
+            #print(file_id)
+            #if Chrom not in file.contigs: break
+            file_data_dict = {}
+        
+            # dictionary for sample file
+            file_data_dict['s'] = []
+            file_data_dict['e'] = []
+        
+            # variable for each column
+            file_start = file_data_dict['s']
+            file_end = file_data_dict['e']
+        
+            if file_id == 0:
+
+                schema = {"s": pl.Int32,
+                         "e": pl.Int32,
+                         "c": pl.Categorical,
+                         "r": pl.Categorical,
+                         "i": pl.Categorical,
+                         "s0": pl.Categorical}
+                
+                # dictionary for sample file
+                file_data_dict['c'] = [] # chrom
+                file_data_dict['r'] = [] # ref
+                file_data_dict['i'] = [] # info
+                file_data_dict['s0'] = [] # sample
+                
+                # variable for each column
+                file_ref = file_data_dict['r']
+                file_info = file_data_dict['i']
+                file_sample = file_data_dict['s0']
+             
+
+                for line in tbx.fetch(Chrom, Start[0], End[1]):
+                    line = line.strip().split('\t')
+                    chrom = line[0]
+                    start = int(line[1])
+                    end = int(line[2])
+                    
+                    if (start>=Start[0]) and (end<=End[1]):
+                        if start==Start[0]:
+                            if end==Start[1]: pass
+                            else: continue
+                        pass
+                    elif start<Start[0]:
+                        continue
+                    elif start>=End[0]: break
+                    
+                    motif_value = line[3]
+                    ref_value = end-start # +1)//period_value
+                    del line
+                    
+                    ref_string = True
+                    has_region = False
+
+                    if Chrom in file.contigs:
+                        for entry in file.fetch(chrom, start+1, end):
+                            entry = entry.strip().split('\t')
+                            st = int(entry[1])
+                            if (st-1)!=start: # -1 to match with 0-based coord
+                                continue
+
+                            info = entry[7].split(';', 5)[:5]
+                            en = int(info[4].split('=')[1])
+                            if ((st-1)==start) & (en==end): # -1 to match with 0-based coord
+                                has_region = True
+                                file_start.append(st) 
+                                file_end.append(en)
+                                file_ref.append(entry[3])
+                                file_info.append(f"MOTIF={motif_value};START={start};END={end}")
+                                sample = entry[9]
+                                if sample[0]=='.':
+                                    file_sample.append(None)
+                                else:
+                                    file_sample.append(entry[4]+':'+':'.join(sample.split(':', 9)[:9]))
+                                del entry
+                                del sample
+                            break
+                            
+                    if not has_region:
+                        file_start.append(start+1)
+                        file_end.append(end)
+                        file_ref.append(ref_file.fetch(chrom, start, end))
+                        file_info.append(f"MOTIF={motif_value};START={start};END={end}")
+                        file_sample.append(None)
+
+                file_count += 1
+                
+                file_data_dict['c'].extend([Chrom]*len(file_start))
+                df = pl.DataFrame(file_data_dict, schema=schema).lazy()
+                df = df.unique(subset=['s', 'e'], keep='first', maintain_order=True)
+                frames.append(df)
+                base_frame = df.collect().select(['s', 'e']).lazy()
+                del df
+                #print('base_frame shape = ', base_frame.collect().shape)
+            else:
+                file_count += 1
+                
+                schema = {"s": pl.Int32,
+                         "e": pl.Int32,
+                         f's{file_id}': pl.Categorical}
+
+                file_data_dict[f's{file_id}'] = [] # sample
+                file_sample = file_data_dict[f's{file_id}']
+
+                if file_count >= 200:
+                    joiner(frames, parquet_batch, tidx, outfile)
+                    parquet_batch += 1
+                    del frames
+                    frames = []
+                    frames.append(base_frame)
+                    file_count = 0
+
+                if Chrom not in file.contigs:
+                    df = pl.DataFrame(file_data_dict, schema=schema).lazy()
+                    frames.append(df)
+                    print(f'Continuing due to no chr {Chrom} in {file_id}')
+                    continue
+
+                for entry in file.fetch(Chrom, Start[0], End[1]):
+                    entry = entry.strip().split('\t')
+                    
+                    sample = entry[9]
+                    if sample[0] == '.':
+                        continue
+                    else:
+                        st = int(entry[1])
+                        info = entry[7].split(';', 5)[:5]
+                        en = int(info[4].split('=')[1])
+                        
+        
+                        file_start.append(st)
+                        file_end.append(en)
+                        file_sample.append(entry[4]+':'+':'.join(sample.split(':', 9)[:9]))
+                        
+                df = pl.DataFrame(file_data_dict, schema=schema).lazy()
+                df = df.unique(subset=['s', 'e'], keep='first', maintain_order=True)
+                frames.append(df)
+                del df
+
+        if frames:
+            joiner(frames, parquet_batch, tidx, outfile)
+            parquet_batch += 1
+            del frames
+
+        # print('Done reading & joining!!!!!!!!!')
+        if thread_pool:
+            # joining previous threads - waiting for previous threads to be over
+            for thread_x in thread_pool:
+                # print('waiting for ', thread_x)
+                thread_x.join()
+            thread_pool.clear()
+
+            # print('Concatenating processor files..............')
+            for each_thread in range(process_thread):
+                thread_out = f'{outfile}_reader{tidx}_processor{each_thread}.vcf'
+                # print('opening ', thread_out)
+                with open(thread_out, 'r') as fh:
+                    for line in fh:
+                        repeat_info = line.strip().split('\t')
+                        tot_tabs = len(repeat_info)
+                        chunk_size = 100
+                        for i in range(0, tot_tabs, chunk_size):
+                            chunk = repeat_info[i:i + chunk_size]
+                            out.write("\t".join(map(str, chunk)))
+                            if i<tot_tabs-1:
+                                out.write("\t")
+                        out.write("\n")
+                        del repeat_info
+                        #out.write("\t".join(map(str, repeat_info)) + "\n")
+                # print('Removing ', thread_out)
+                #del repeat_info
+                os.remove(thread_out)
+
+        batch_files = [f"{outfile}_reader{tidx}_batch{batch_val}.parquet" for batch_val in range(parquet_batch)]
+        parquet_frames = [pl.read_parquet(f).lazy() for f in batch_files]
+        for p_files in batch_files:
+            os.remove(p_files)
+        
+        if parquet_frames:
+            merged = reduce(lambda l, r: l.join(r, on=['s','e'], how='left'), parquet_frames)
+            whole_df = merged.collect(engine="streaming")
+            print("Shape = ", whole_df.shape)
+            
+            if process_thread > 0:
+                loci_count = whole_df.shape[0]
+                split_count = loci_count // process_thread
+                if split_count == 0:
+                    split_count = 1
+                initial = 0
+                track = split_count
+        
+                # initializing threads
+                for each_thread in range(process_thread):
+                    if each_thread+1 == process_thread:
+                        process_df = whole_df[initial : ]
+                    else:
+                        process_df = whole_df[initial : track]
+                        
+                    thread_x = threading.Thread(target = processor, args = (process_df, outfile, tidx, each_thread, total_samples))
+                    thread_x.start()
+                    thread_pool.append(thread_x)
+                    
+                    initial = track
+                    track += split_count
+    
+            else:
+                processor(whole_df, outfile, tidx, 0, total_samples)
+                thread_out = f'{outfile}_reader{tidx}_processor{0}.vcf'
+                with open(thread_out, 'r') as fh:
+                    for line in fh:
+                        repeat_info = line.strip().split('\t')
+                        out.write("\t".join(map(str, repeat_info)) + "\n")
+                os.remove(thread_out)
+    
+            del whole_df
+
+    if thread_pool:
+        # joining previous threads - waiting for previous threads to be over
+        for thread_x in thread_pool:
+            # print('waiting for ', thread_x)
+            thread_x.join()
+        thread_pool.clear()
+    
+        # print('Concatenating processor files..............')
+        for each_thread in range(process_thread):
+            thread_out = f'{outfile}_reader{tidx}_processor{each_thread}.vcf'
+            # print('opening ', thread_out)
+            with open(thread_out, 'r') as fh:
+                for line in fh:
+                    repeat_info = line.strip().split('\t')
+                    out.write("\t".join(map(str, repeat_info)) + "\n")
+            # print('Removing ', thread_out)
+            os.remove(thread_out)
+    
+    for i in vcf_instance:
+        i.close()
+    ref_file.close()
+    tbx.close()
+    out.close()
+
+
+def joiner(frames, parquet_batch, tidx, outfile):
+    base = reduce(lambda l, r: l.join(r, on=['s', 'e'], how='left'), frames)
+    df = base.collect(engine="streaming")
+    df.write_parquet(f"{outfile}_reader{tidx}_batch{parquet_batch}.parquet", compression="zstd")
+
+
+def vcf_writer(out, bam_name, source_vcf_path):
+
+    source_vcf = pysam.VariantFile(source_vcf_path)
+
+    vcf_header = pysam.VariantHeader()
+
+    # command
+    vcf_header.add_line(f"##command=Tamatr {' '.join(sys.argv)}")
+
+    # print(source_vcf)
+
+    for contig, metadata in source_vcf.header.contigs.items():
+        vcf_header.contigs.add(contig, length=metadata.length)
+    source_vcf.close()
+    
+    #sample_name
+    for each_sample in bam_name:
+        vcf_header.add_sample(each_sample)
+    # FILTER
+    vcf_header.filters.add('LESS_READS', number=None, type=None, description="Read depth below threshold")
+    # INFO
+    vcf_header.info.add("AC",    number='A', type="Integer", description="Number of alternate alleles in called genotypes")
+    vcf_header.info.add("AN",    number=1,   type="Integer", description="Number of alleles in called genotypes")
+    vcf_header.info.add("MOTIF", number=1,   type="String", description="Repeat motif")
+    vcf_header.info.add("START", number=1,   type="Integer", description="Start position of the repeat region in 0-based coordinate system")
+    vcf_header.info.add("END",   number=1,   type="Integer", description="End position of the repeat region")
+    vcf_header.info.add("ID",    number=1,   type="String", description="Locus identifier tag")
+    vcf_header.info.add("CT",    number=1,   type="String", description="Cluster type")
+    vcf_header.info.add("EAC",   number=1,   type="String", description="Each Allele Count")
+    # FORMAT
+    vcf_header.formats.add("GT", number=1,   type="String", description="Genotype")
+    vcf_header.formats.add("AL", number=2, type="Integer", description="Allele length in base pairs")
+    vcf_header.formats.add("AR", number='.', type="String", description="Allele length range")
+    vcf_header.formats.add("SD", number='.', type="Integer", description="Number of reads supporting for the alleles")
+    vcf_header.formats.add("PC", number=2, type="Integer", description="Number of reads in the phased cluster for each allele")
+    vcf_header.formats.add("DP", number=1, type="Integer", description="Number of the supporting reads for the repeat locus")
+    vcf_header.formats.add("SN", number='.', type="Integer", description="Number of SNPs used for phasing")
+    vcf_header.formats.add("SQ", number='.', type="Float", description="Phred-scale qualities of the SNPs used for phasing")
+    vcf_header.formats.add("MM", number='.', type="Float", description="Mean methylation level for each allele")
+    vcf_header.formats.add("MR", number='.', type="Integer", description="Number of reads providing methylation info for each allele")
+    vcf_header.formats.add("DS", number='A', type="String", description="Motif decomposed sequence")
+    vcf_header.formats.add("MV", number='.', type="String", description="Visual methylation encodings for the alleles")
+
+    out.write(str(vcf_header))
\ No newline at end of file
diff --git a/ATARVA/vcf_writer.py b/ATARVA/vcf_writer.py
index 0c739ca..d9c832c 100644
--- a/ATARVA/vcf_writer.py
+++ b/ATARVA/vcf_writer.py
@@ -1,164 +1,384 @@
 import sys
 import pysam
-from ATARVA.consensus import consensus_seq_poa
+import numpy as np
+from ATARVA.decompose import motif_decomposition
+
+
+INFO_MP_CUTOFF = 0.5
+def set_info_mp_cutoff(val):
+    global INFO_MP_CUTOFF
+    INFO_MP_CUTOFF = val
+
 
 def vcf_writer(out, bam, bam_name):
+    """
+    Initialize the VCF header and write to output file
+
+    :param out: output file handle
+    :param bam: pysam AlignmentFile object for the input BAM file
+    :param bam_name: sample name for the BAM file, to be added in the VCF header
+    """
 
     vcf_header = pysam.VariantHeader()
 
     # command
-    vcf_header.add_line(f"##command=ATaRVa {' '.join(sys.argv)}")
+    vcf_header.add_line(f"##command=ATaRVa_0.6.0 {' '.join(sys.argv)}")
 
     for contig in bam.header['SQ']:
         vcf_header.contigs.add(contig['SN'], length=contig['LN'])
     #sample_name
     vcf_header.add_sample(bam_name)
+
     # FILTER
     vcf_header.filters.add('LESS_READS', number=None, type=None, description="Read depth below threshold")
+
     # INFO
-    vcf_header.info.add("AC", number='A', type="Integer", description="Number of alternate alleles in called genotypes")
-    vcf_header.info.add("AN", number=1, type="Integer", description="Number of alleles in called genotypes")
-    vcf_header.info.add("MOTIF", number=1, type="String", description="Repeat motif")
-    vcf_header.info.add("END", number=1, type="Integer", description="End position of the repeat region")
+    vcf_header.info.add("AC",    number='A', type="Integer",  description="Number of alternate alleles in called genotypes")
+    vcf_header.info.add("AN",    number=1,   type="Integer",  description="Number of alleles in called genotypes")
+    vcf_header.info.add("MOTIF", number=1,   type="String",   description="Repeat motif")
+    vcf_header.info.add("START", number=1,   type="Integer",  description="Start position of the repeat region in 0-based coordinate system")
+    vcf_header.info.add("END",   number=1,   type="Integer",  description="End position of the repeat region")
+    vcf_header.info.add("ID",    number=1,   type="String",   description="Locus identifier tag")
+    vcf_header.info.add("REFCN", number=1,   type="Integer",  description="Reference allele copy number")
+    vcf_header.info.add("CT",    number=1,   type="String",   description="Cluster type")
+    vcf_header.info.add("MPC",   number=1,   type="String",   description=f"{INFO_MP_CUTOFF}")
+    vcf_header.info.add("AFD",   number=1,   type="String",   description="Allele length frequency for the reads supporting the locus")
+
     # FORMAT
-    vcf_header.formats.add("GT", number=1, type="String", description="Genotype")
-    vcf_header.formats.add("AL", number=2, type="Integer", description="Allele length in base pairs")
-    vcf_header.formats.add("SD", number='.', type="Integer", description="Number of reads supporting for the alleles")
-    vcf_header.formats.add("PC", number=2, type="Integer", description="Number of reads in the phased cluster for each allele")
-    vcf_header.formats.add("DP", number=1, type="Integer", description="Number of the supporting reads for the repeat locus")
-    vcf_header.formats.add("SN", number='.', type="Integer", description="Number of SNPs used for phasing")
-    vcf_header.formats.add("SQ", number='.', type="Float", description="Phred-scale qualities of the SNPs used for phasing")
+    vcf_header.formats.add("GT", number=1,   type="String",   description="Genotype")
+    vcf_header.formats.add("AL", number=2,   type="Integer",  description="Allele length in base pairs")
+    vcf_header.formats.add("CN", number=2,   type="Integer",  description="Motif copy number for each allele")
+    vcf_header.formats.add("AR", number='.', type="String",   description="Allele length range")
+    vcf_header.formats.add("SD", number='.', type="Integer",  description="Number of reads supporting each haplogroup")
+    vcf_header.formats.add("DP", number=1,   type="Integer",  description="Total supporting reads for the repeat locus")
+    vcf_header.formats.add("SN", number='.', type="Integer",  description="Number of informative SNPs used for phasing")
+    vcf_header.formats.add("SQ", number='.', type="Float",    description="Average Phred-scale base call quality of each informative SNP across the supporting reads")
+    vcf_header.formats.add("MA", number='.', type="Float",    description="Average  methylation level for each allele")
+    vcf_header.formats.add("MR", number='.', type="Integer",  description="Number of informative reads for methylation scoring for each allele")
+    vcf_header.formats.add("DS", number='A', type="String",   description="Motif decomposed sequence for each allele sequence")
+    vcf_header.formats.add("MV", number='.', type="String",   description="Base methylation score encoded for visualization for each allele")
 
     out.write(str(vcf_header))
-    # print(*['#CHROM', 'POS', 'ID', 'REF', 'ALT', 'QUAL', 'FILTER', 'INFO', 'FORMAT', 'SAMPLE'], file=out, sep='\t')
 
-def vcf_homozygous_writer(ref, contig, locus_key, global_loci_info, homozygous_allele, global_loci_variations, reads_len, out, hap_reads):
 
-    locus_start = int(global_loci_info[locus_key][1])
-    locus_end = int(global_loci_info[locus_key][2])
-    
+def write_fail_call(cooper, locus_key):
+    """
+    entry for vcf failed call
 
-    if type(reads_len) == list:
-        reads_len = len(reads_len) #removable
-    
-    ref_allele_length = locus_end - locus_start
-    DP = len(global_loci_variations[locus_key]['reads'])
+    :param cooper: Cooper object containing the locus information
+    :param locus_key: key for the locus in the format 'chrom:start-end'
+    :param skip_point: integer indicating the reason for failure, to be added in the FILTER column of the VCF
+    """
+    FILTER = ''
+    locus = cooper.cooper_loci_info[locus_key]
+    depth = 0
+    if locus_key not in cooper.cooper_loci_data:
+        FILTER = 'LESS_READS'
+    else:
+        locus_data = cooper.cooper_loci_data[locus_key]
+        refcn = str(locus.length // locus.motif_length)
 
-    AC = 0; AN = 2; GT = '0/0'; ALT = '.'
-    if homozygous_allele != ref_allele_length:
-        AC = 2
-        GT = '1/1'
-        seqs = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads] if seq!='']
-        if len(seqs)>0:
-            ALT = consensus_seq_poa(seqs, homozygous_allele)
-        else: ALT = '<DEL>'
+        if locus_data.skip_code == 0:   FILTER = 'LESS_READS'
+        depth = locus_data.depth
 
-    # INFO = 'AC=' + str(AC) + ';AN=' + str(AN) + ';DP=' + str(DP)+ ';END=' + str(locus_end)
+    # --- locus optional tag ---
+    optional_tag = f';ID={locus.name}' if locus.name else ';ID=.'
 
-    INFO = 'AC=' + str(AC) + ';AN=' + str(AN) + ';MOTIF=' + str(global_loci_info[locus_key][3]) + ';END=' + str(locus_end)
+    INFO = 'AC=0;AN=0;MOTIF=' + str(locus.motif) + ';START=' + str(locus.start) + ';END=' + str(locus.end) + optional_tag + ';REFCN='+refcn
+    FORMAT = 'GT:AL:CN:AR:SD:DP:SN:SQ:MA:MR:DS:MV'
+    SAMPLE = f'.:.:.:.:.:{depth}:.:.:.:.:.:.'
 
-    # FORMAT = 'GT:AL:SD'
-    # SAMPLE = str(GT) + ':' + str(homozygous_allele) + ',' + str(homozygous_allele) + ':' + str(reads_of_homozygous)
+    print(*[locus.chrom, locus.start + 1, '.',  cooper.ref.fetch(locus.chrom, locus.start, locus.end), '.', 0, FILTER, INFO, FORMAT, SAMPLE], file=cooper.outhandle, sep='\t')
 
-    FORMAT = 'GT:AL:SD:PC:DP:SN:SQ'
-    SAMPLE = str(GT) + ':' + str(homozygous_allele) + ',' + str(homozygous_allele) + ':' + str(reads_len) + ':.:' + str(DP) + ':.:.'
 
-    print(*[contig, locus_start, '.',  ref.fetch(contig, locus_start, locus_end), ALT , 0, 'PASS', INFO, FORMAT, SAMPLE], file=out, sep='\t')
-    del global_loci_info[locus_key]
+def write_homozygous_call(cooper, locus_key):
+    """
+    write a homozygous VCF record for a given locus.
 
+    :param cooper:           cooper object
+    :param locus_key:        locus identifier string
+    """
+    locus = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
 
-def vcf_heterozygous_writer(contig, genotypes, locus_start, global_loci_variations, locus_end, allele_count, DP, global_loci_info, ref, out, chosen_snpQ, phased_read, snp_num, hap_reads):
+    # --- locus optional tag ---
+    optional_tag = f';ID={locus.name}' if locus.name else ';ID=.'
 
-    locus_key = f'{contig}:{locus_start}-{locus_end}'
-    final_allele = set(genotypes)
-    heterozygous_allele = ''
-    AC = 'AC'
-    AN = 2
-    GT = 'GT'
-    SD = 'SD'
-    PC = 'PC'
+    # --- methylation fields ---
+    if locus_data.hap_meth_data is not None and locus_data.hap_meth_data[0] is not None:
+        meth_avg_prob, meth_read_count, meth_vis_enc = locus_data.hap_meth_data[0]
+    else:
+        meth_avg_prob, meth_read_count, meth_vis_enc = None, None, None
+
+    meth_prob_str  = str(meth_avg_prob)   if meth_avg_prob   is not None else '.'
+    meth_reads_str = str(meth_read_count) if meth_read_count is not None else '.'
+    meth_vis_str   = meth_vis_enc         if meth_vis_enc    is not None else '.'
+
+    # homozygous — duplicate values for diploid FORMAT consistency
+
+    allele = locus_data.gt_aseqs[0] if locus_data.gt_aseqs else None
+
+    # --- ref / alt ---
+    ref_seq    = cooper.ref.fetch(cooper.chrom, locus.start, locus.end)
+    is_alt     = allele and ref_seq != allele
+    is_seq_alt = is_alt and not allele.startswith('<')
+
+    AC  = 2       if is_alt else 0
+    GT  = '1/1'   if is_alt else '0/0'
+    ALT = allele  if is_alt else '.'
+
+    # --- copy number fields ---
+    allele_length = 0 if allele == '<DEL>' else len(allele)
+    ref_units  = locus.length  // locus.motif_length
+    motif_copy = allele_length // locus.motif_length
+
+    # --- decomposed sequence ---
+    if cooper.args.decompose and is_seq_alt and locus.motif_length <= 10:
+        decomposed_seq = locus_data.gt_decomp_seqs[0] if locus_data.gt_decomp_seqs[0] else None
+    else: decomposed_seq = '.'
+
+    # --- INFO field ---
+    INFO = (
+        f'AC={AC};AN=2'
+        f';MOTIF={locus.motif}'
+        f';START={locus.start}'
+        f';END={locus.end}'
+        f'{optional_tag}'
+        f';REFCN={ref_units}'
+    )
+
+    if cooper.args.debug_mode:
+        alen_dist   = sorted(locus_data.halen_frequency.items(), key=lambda x: x[1], reverse=True)
+        INFO += f';CT=<TAG>'
+
+    # --- SAMPLE field ---
+    FORMAT = 'GT:AL:CN:AR:SD:DP:SN:SQ:MA:MR:DS:MV'
+
+    allele_length = 0 if allele == '<DEL>' else len(allele)
+    depth         = locus_data.depth
+    hap_depth     = depth
+    length_GT     = f'{allele_length}' if cooper.haploid else f'{allele_length},{allele_length}'
+    units_GT      = f'{motif_copy}' if cooper.haploid else f'{motif_copy},{motif_copy}'
+    allele_range  = f'{locus_data.gt_arange[0]}' if cooper.haploid else f'{locus_data.gt_arange[0]},{locus_data.gt_arange[1]}'
+    GT            = GT if not cooper.haploid else GT[0]  # convert to haploid GT if needed
+    MA = f'{meth_prob_str}'  if cooper.haploid else f'{meth_prob_str},{meth_prob_str}'
+    MV = f'{meth_vis_str}'   if cooper.haploid else f'{meth_vis_str},{meth_vis_str}'
+    MR = f'{meth_reads_str}' if cooper.haploid else f'{meth_reads_str},{meth_reads_str}'
+    SAMPLE = (
+            f'{GT}'
+            f':{length_GT}'
+            f':{units_GT}'
+            f':{allele_range}'
+            f':{hap_depth}'
+            f':{depth}'
+            f':.:.'
+            f':{MA}'
+            f':{MR}'
+            f':{decomposed_seq}'
+            f':{MV}'
+        )
+
+    # --- write VCF record ---
+    print(cooper.chrom, locus.start + 1, '.', ref_seq, ALT, 0, 'PASS', INFO, FORMAT, SAMPLE, file=cooper.outhandle, sep='\t')
+
+
+def write_heterozygous_call(cooper, locus_key):
+    """
+    write a heterozygous VCF record for a given locus.
+
+    :param cooper:           cooper object
+    :param locus_key:        locus identifier string
+    """
+
+    locus = cooper.cooper_loci_info[locus_key]
+    locus_data = cooper.cooper_loci_data[locus_key]
+
+    if locus.name is not None:
+        optional_tag = f';ID={locus.name}'
+    else: optional_tag = ';ID=.'
+
+    length_GT = ''
+    units_GT = ''
+    AC  = 'AC'
+    AN  = 2
+    GT  = 'GT'
+    SD  = 'SD'
     ALT = '.'
 
-    ref_allele_length = locus_end - locus_start
+    ref_alen   = locus.end - locus.start
+    ref_allele = cooper.ref.fetch(cooper.chrom, locus.start, locus.end)
+    ref_units = str(ref_alen // locus.motif_length)
+
+    meth_prob   = []
+    meth_reads  = []
+    meth_viztag = []
+    for hap_methyl in locus_data.hap_meth_data:
+        meth_prob.append(str(hap_methyl[0]) if hap_methyl[0] is not None else '.') #methylation probability
+        meth_reads.append(str(hap_methyl[1]) if hap_methyl[1] is not None else '.') #number of methylated reads
+        meth_viztag.append(hap_methyl[2] if hap_methyl[2] is not None else '.') #methylation visual encoding
 
-    if len(final_allele) == 1:
-        # AN = 1
-        if ref_allele_length == tuple(final_allele)[0]:
-            AC = 0
-            GT = '0|0'
-            heterozygous_allele+=str(ref_allele_length)+','+str(ref_allele_length)
-            SD = str(allele_count[ref_allele_length])+','+str(allele_count[str(ref_allele_length)])
+    if locus_data.gt_aseqs[0] == locus_data.gt_aseqs[1]: # if the two alleles are the same, make it a homozygous call
+        allele = locus_data.gt_aseqs[0]
+        if ref_allele == allele:
+            AC = 0; GT = '0|0'
         else:
             AC = 2; GT = '1|1'
-            heterozygous_allele+=str(tuple(final_allele)[0])+','+str(tuple(final_allele)[0])
-            SD = str(allele_count[tuple(final_allele)[0]])+','+str(allele_count[str(tuple(final_allele)[0])])
-            seqs = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads[0]] if seq!='']
-            if len(seqs)>0:
-                ALT = consensus_seq_poa(seqs, genotypes[0])
-            else: ALT = '<DEL>'
-        PC = str(phased_read[0])+','+str(phased_read[1])
+            ALT = allele
+        allele_length = 0 if allele == '<DEL>' else len(allele)
+        length_GT += f'{allele_length},{allele_length}'
+        units_GT += f'{allele_length//locus.motif_length},{allele_length//locus.motif_length}'
+        SD = f'{len(locus_data.hap_read_sets[0])},{len(locus_data.hap_read_sets[1])}'
+        allele_range = f'{locus_data.gt_arange[0]},{locus_data.gt_arange[1]}'
+
     else:
-        # AN = 2
-        if len(set((ref_allele_length,)) & final_allele) == 1:
+        if ref_allele in locus_data.gt_aseqs:
+            ref_index = 0; allele_index = 1
+            if locus_data.gt_aseqs[0] != ref_allele:
+                allele_index = 0
+                ref_index = 1
+            allele = locus_data.gt_aseqs[allele_index]
             AC = 1
             GT = '0|1'
-            heterozygous_allele+=str(ref_allele_length)+','+str(tuple(final_allele-{ref_allele_length})[0])
-            SD = str(allele_count[ref_allele_length])+','+str(allele_count[tuple(final_allele-{ref_allele_length})[0]])
-            if genotypes.index(ref_allele_length) == 0:
-                PC = str(phased_read[0])+','+str(phased_read[1])
-                seqs = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads[1]] if seq!='']
-                if len(seqs)>0:
-                    ALT = consensus_seq_poa(seqs, genotypes[1])
-                else: ALT = '<DEL>'
-                # ALT = consensus_seq_poa([global_loci_variations[locus_key]['read_sequence'][read_id] for read_id in hap_reads[1]])
-            else:
-                PC = str(phased_read[1])+','+str(phased_read[0])
-                seqs = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads[0]] if seq!='']
-                if len(seqs)>0:
-                    ALT = consensus_seq_poa(seqs, genotypes[0])
-                else: ALT = '<DEL>'
-                # ALT = consensus_seq_poa([global_loci_variations[locus_key]['read_sequence'][read_id] for read_id in hap_reads[0]])
+            allele_length = 0 if allele == '<DEL>' else len(allele)
+            length_GT += f'{ref_alen},{allele_length}'
+            units_GT += f'{ref_units},{allele_length//locus.motif_length}'
+
+            SD = f'{len(locus_data.hap_read_sets[ref_index])},{len(locus_data.hap_read_sets[allele_index])}'
+            ALT = allele
+            if ref_index == 1:
+                meth_prob = meth_prob[::-1] # reverse the meth_prob to keep the order consistent with GT
+                meth_reads = meth_reads[::-1]
+                meth_viztag = meth_viztag[::-1]
+            allele_range = f'{locus_data.gt_arange[ref_index]},{locus_data.gt_arange[allele_index]}'
         else:
             AC = '1,1'
             GT = '1|2'
-            heterozygous_allele+=str(genotypes[0])+','+str(genotypes[1])
-            SD = str(allele_count[genotypes[0]])+','+str(allele_count[genotypes[1]])
-            PC = str(phased_read[0])+','+str(phased_read[1])
-            seqs1 = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads[0]] if seq!='']
-            if len(seqs1)>0:
-                ALT1 = consensus_seq_poa(seqs1, genotypes[0])
-            else: ALT1 = '<DEL>'
-            seqs2 = [seq for seq in [global_loci_variations[locus_key]['read_sequence'][read_id][0] for read_id in hap_reads[1]] if seq!='']
-            if len(seqs2)>0:
-                ALT2 = consensus_seq_poa(seqs2, genotypes[1])
-            else: ALT2 = '<DEL>'
-            ALT = ALT1 + ',' + ALT2
-            # ALT = consensus_seq_poa([global_loci_variations[locus_key]['read_sequence'][read_id] for read_id in hap_reads[0]]) + ',' + consensus_seq_poa([global_loci_variations[locus_key]['read_sequence'][read_id] for read_id in hap_reads[1]])
+            ALT1 = locus_data.gt_aseqs[0]
+            ALT2 = locus_data.gt_aseqs[1]
+            length_GT += f'{len(ALT1)},{len(ALT2)}'
+            units_GT += f'{len(ALT1)//locus.motif_length},{len(ALT2)//locus.motif_length}'
 
-    # INFO = 'AC='+str(AC)+';AN='+str(AN)+';DP='+str(DP)+';END='+str(locus_end)+';PC='+PC+';SN='+str(snp_num)+';SQ='+chosen_snpQ
+            SD = f'{len(locus_data.hap_read_sets[0])},{len(locus_data.hap_read_sets[1])}'
 
-    if PC == '.,.': PC = '.' # due  to length genotyper
-    INFO = 'AC='+str(AC)+';AN='+str(AN)+';MOTIF=' + str(global_loci_info[locus_key][3]) + ';END='+str(locus_end)
+            ALT = f'{ALT1},{ALT2}'
+            allele_range = f'{locus_data.gt_arange[0]},{locus_data.gt_arange[1]}'
+    MA = ','.join(meth_prob)
+    MR = ','.join(meth_reads)
+    MV = ','.join(meth_viztag)
 
-    # FORMAT = 'GT:AL:SD'
-    # SAMPLE = str(GT)+':'+heterozygous_allele+':'+SD
+    INFO = f'AC={AC};AN={AN};MOTIF={locus.motif};START={locus.start};END={locus.end}{optional_tag};REFCN={ref_units}'
 
-    FORMAT = 'GT:AL:SD:PC:DP:SN:SQ'
-    SAMPLE = str(GT)+':'+heterozygous_allele+':' + SD + ':' + PC + ':' + str(DP) + ':' + str(snp_num) + ':' + chosen_snpQ
+    decomposed_seqs = '.,.'
+    if cooper.args.decompose:
+        decomposed_seqs = f'{locus_data.gt_decomp_seqs[0]},{locus_data.gt_decomp_seqs[1]}'
 
-    print(*[contig, locus_start, '.',  ref.fetch(contig, locus_start, locus_end), ALT, 0, 'PASS', INFO, FORMAT, SAMPLE], file=out, sep='\t')
-    del global_loci_info[locus_key]
+    num_snps = 0
+    snp_quals = ''
+    if locus_data.phase_mode == 'snp' and locus_data.phasing_snp_quals:
+        num_snps  = locus_data.n_phasing_snps
+        snp_quals = locus_data.phasing_snp_quals
+    FORMAT = 'GT:AL:CN:AR:SD:DP:SN:SQ:MA:MR:DS:MV'
+    SAMPLE = (
+            f'{GT}'
+            f':{length_GT}'
+            f':{units_GT}'
+            f':{allele_range}'
+            f':{SD}'
+            f':{str(locus_data.depth)}'
+            f':{num_snps}'
+            f':{snp_quals}'
+            f':{MA}'
+            f':{MR}'
+            f':{decomposed_seqs}'
+            f':{MV}'
+        )
 
-def vcf_fail_writer(contig, locus_key, global_loci_info, ref, out, DP, skip_point):
+    print(*[cooper.chrom, locus.start + 1, '.',  ref_allele, ALT, 0, 'PASS', INFO, FORMAT, SAMPLE], file=cooper.outhandle, sep='\t')
 
-    locus_start = int(global_loci_info[locus_key][1])
-    locus_end = int(global_loci_info[locus_key][2])
 
-    if skip_point == 0:
-        FILTER = 'LESS_READS'    
+def vcf_multizygous_writer(contig, genotype_dict, locus_start, locus_end, DP, global_loci_info, ref, out, log_bool, decomp, hallele_counter):
+
     locus_key = f'{contig}:{locus_start}-{locus_end}'
-    INFO = 'AC=0;AN=0;MOTIF=' + str(global_loci_info[locus_key][3]) + ';END=' + str(locus_end)
-    FORMAT = 'GT:AL:SD:PC:DP:SN:SQ'
-    SAMPLE = '.:.:.:.:.:.:.'
-    print(*[contig, locus_start, '.',  ref.fetch(contig, locus_start, locus_end), '.', 0, FILTER, INFO, FORMAT, SAMPLE], file=out, sep='\t')
-    del global_loci_info[locus_key]
+
+    tag = "correlation_clustering"
+
+    if len(global_loci_info[locus_key]) > 5:
+        optional_tag = f';ID={global_loci_info[locus_key][5]}'
+    else:
+        optional_tag = ';ID=.'
+
+    motif_size = int(float(global_loci_info[locus_key][4]))
+
+    GT_dict = {}
+    gt_idx = 0
+    ref_allele_length = locus_end - locus_start
+    refcn = str(ref_allele_length // int(float(global_loci_info[locus_key][4])))
+    ref_seq = ref.fetch(contig, locus_start, locus_end)
+    for each_genotype in genotype_dict:
+        current_gt = genotype_dict[each_genotype]
+        if int(each_genotype) == ref_allele_length:
+            if ref_seq == current_gt[0]:
+                GT_dict[0] = (current_gt[0], str(each_genotype), current_gt[3], f'{current_gt[1][0]}-{current_gt[1][1]}', current_gt[4][0], current_gt[4][1], current_gt[2], current_gt[4][2])
+            else:
+                gt_idx += 1
+                GT_dict[gt_idx] = (current_gt[0], str(each_genotype), current_gt[3], f'{current_gt[1][0]}-{current_gt[1][1]}', current_gt[4][0], current_gt[4][1], current_gt[2], current_gt[4][2])
+        else:
+            gt_idx += 1
+            GT_dict[gt_idx] = (current_gt[0], str(each_genotype), current_gt[3], f'{current_gt[1][0]}-{current_gt[1][1]}', current_gt[4][0], current_gt[4][1], current_gt[2], current_gt[4][2])
+    del genotype_dict
+
+    GT = []
+    if gt_idx> 0:
+        AN = (gt_idx + 1) if (0 in GT_dict) else gt_idx
+    else:
+        AN = 2
+    # AN = (gt_idx + 1) if gt_idx>0 else 2
+    AC = ','.join(['1']*gt_idx) if gt_idx>0 else 0
+    ALT = []
+    AL = []
+    AR = []
+    SD = []
+    MA = []
+    MR = []
+    deseq = []
+    MV = []
+    for gt_key in sorted(GT_dict.keys()):
+        GT.append(str(gt_key))
+        if gt_key != 0:
+            ALT.append(GT_dict[gt_key][0])
+            deseq.append(GT_dict[gt_key][6] if GT_dict[gt_key][6] else '.')
+        AL.append(GT_dict[gt_key][1])
+        SD.append(str(GT_dict[gt_key][2]))
+        AR.append(GT_dict[gt_key][3])
+        MA.append(str(GT_dict[gt_key][4]) if GT_dict[gt_key][4] is not None else '.')
+        MR.append(str(GT_dict[gt_key][5]) if GT_dict[gt_key][5] is not None else '.')
+        MV.append(str(GT_dict[gt_key][7]) if GT_dict[gt_key][5] is not None else '.')
+    del GT_dict
+
+    GT = '/'.join(GT)
+    ALT = ','.join(ALT) if ALT else '.'
+    CN = ','.join([str(i // motif_size) for i in AL])
+    AL = ','.join(AL)
+    AR = ','.join(AR)
+    SD = ','.join(SD)
+    MA = ','.join(MA)
+    MR = ','.join(MR)
+    MV = ','.join(MV)
+
+    if log_bool:
+        eac = sorted(hallele_counter.items(), key = lambda x: x[1], reverse=True)
+        INFO = 'AC='+str(AC)+';AN='+str(AN)+';MOTIF=' + str(global_loci_info[locus_key][3]) + ';START=' + str(locus_start) + ';END='+str(locus_end) + optional_tag + ';REFCN='+refcn + ';CT=' + tag + ';EAC=' + str(eac)
+    else:
+        INFO = 'AC='+str(AC)+';AN='+str(AN)+';MOTIF=' + str(global_loci_info[locus_key][3]) + ';START=' + str(locus_start) + ';END='+str(locus_end) + optional_tag + ';REFCN='+refcn
+
+    if decomp:
+        deseq = ','.join(deseq) if deseq else '.'
+    else:
+        deseq = '.'
+
+    FORMAT = 'GT:AL:CN:AR:SD:DP:SN:SQ:MA:MR:DS:MV'
+    SAMPLE = GT + ':' + AL + ':' + CN + ':' + AR + ':' + SD + ':' + str(DP) + ':.:.:' + MA + ':' + MR + ':' + deseq + ':' + MV
+
+    print(*[contig, locus_start+1, '.',  ref_seq, ALT, 0, 'PASS', INFO, FORMAT, SAMPLE], file=out, sep='\t')
+
+    del GT, ALT, AL, CN, AR, SD, MA, MR, MV, deseq, global_loci_info[locus_key]