shell: """
java -Xmx{params.memory}g -cp {params.amber_jar} \\
    com.hartwig.hmftools.amber.AmberApplication \\
        -tumor {params.tumor} {params.normal_name} \\
        -tumor_bam {input.tumor}  {params.normal_bam} \\
        -output_dir {params.outdir} \\
        -threads {threads} {params.tumor_flag} \\
        -loci {params.loci_ref}
"""

shell: """
java -Xmx{params.memory}g -cp {params.cobalt_jar} \\
    com.hartwig.hmftools.cobalt.CountBamLinesApplication \\
        -tumor {params.tumor} {params.normal_name} \\
        -tumor_bam {input.tumor}  {params.normal_bam} \\
        -output_dir {params.outdir} \\
        -threads {threads} {params.tumor_flag} \\
        -gc_profile {params.gc_profile}
"""

shell: """
# Create GatherBQSR list
find {params.bams} -iname '{params.sample}_recal*_data.grp' \\
    > {output.lsl}
# Gather per sample BQSR results
gatk --java-options '-Xmx{params.memory}g' GatherBQSRReports \\
    --use-jdk-inflater --use-jdk-deflater \\
    -I {output.lsl} \\
    -O {output.recal}
"""

shell: """
# Setups temporary directory for
# intermediate files with built-in 
# mechanism for deletion on exit
if [ ! -d "{params.tmpdir}" ]; then mkdir -p "{params.tmpdir}"; fi
tmp=$(mktemp -d -p "{params.tmpdir}")
trap 'rm -rf "${{tmp}}"' EXIT

run_deepvariant \\
    --model_type=WGS \\
    --ref={params.genome} \\
    --reads={input.bam} \\
    --output_gvcf={output.gvcf} \\
    --output_vcf={output.vcf} \\
    --num_shards={threads} \\
    --intermediate_results_dir=${{tmp}}
"""

shell: """
gatk --java-options '-Xmx{params.memory}g -XX:ParallelGCThreads={threads}' SelectVariants \\
    -R {params.genome} \\
    --variant {input.vcf} \\
    --sample-name {params.sample} \\
    --exclude-non-variants \\
    --output {output.vcf}
"""

shell: """
# Environment variable for modules dir
export OC_MODULES="{params.module}"

oc run \\
    -t vcf \\
    -x \\
    --newlog \\
    --cleanrun \\
    --system-option "modules_dir={params.module}" \\
    -a {params.annot} \\
    -n {params.prefix} \\
    -l {params.genome} \\
    -d {params.outdir} \\
    --mp {threads} \\
    {input.vcf}
"""

shell: """
oc util mergesqlite \\
    -o {output.merged} \\
    {input.dbs} 
"""

shell: """
# Environment variable for modules dir
export OC_MODULES="{params.module}"

oc run \\
    -t vcf \\
    -x \\
    --newlog \\
    --cleanrun \\
    --system-option "modules_dir={params.module}" \\
    -a {params.annot} \\
    -n {params.prefix} \\
    -l {params.genome} \\
    -d {params.outdir} \\
    --mp {threads} \\
    {input.vcfs}
"""

    shell: """
# Create first filtering script,
# Filters based on AF 
mkdir -p {params.scripts}
cp {input.db} {output.filter_1} 
cat << EOF > {params.filter_1}
import sqlite3
import os

maf = str({params.maf_thres})
mafc = str(1 - float({params.maf_thres}))
so = "{params.so}"
conn = sqlite3.connect("{output.filter_1}")
conn.isolation_level = None
cursor = conn.cursor()
conn.execute('CREATE TABLE variant2 AS SELECT * FROM variant WHERE (base__so IN (' + '"' + '", "'.join(so.split(',')) + '"' + ')) AND ((gnomad__af IS NULL AND gnomad3__af IS NULL AND thousandgenomes__af IS NULL) OR (gnomad__af <= ' + maf +' OR gnomad__af >= '+mafc+' OR gnomad3__af <= '+maf+' OR gnomad3__af >= '+mafc+' OR thousandgenomes__af <= '+maf+' OR thousandgenomes__af >= '+mafc+'))')
conn.execute('DROP TABLE variant')
conn.execute('ALTER TABLE variant2 RENAME TO variant')
conn.execute('DELETE from sample WHERE base__uid NOT IN (SELECT base__uid FROM variant)')
conn.execute('DELETE FROM gene WHERE base__hugo NOT IN (SELECT base__hugo FROM variant)')
conn.execute('DELETE FROM mapping WHERE base__uid NOT IN (SELECT base__uid FROM variant)')
conn.execute('UPDATE info SET colval = (SELECT COUNT(*) FROM variant) WHERE colkey == "Number of unique input variants"')
conn.execute('VACUUM')
conn.close()
EOF

# Create second filtering script,
# Filters based on filters in config
cp {output.filter_1} {output.filter_2}
cat << EOF > {params.filter_2}
import pandas as pd
import sqlite3
import os

conn = sqlite3.connect("{output.filter_2}")
conn.isolation_level = None
cursor = conn.cursor()
filter = {params.secondary}

def keep(dd, used_annotators):
    final_annotators = {{annotator: dd[annotator] for annotator in used_annotators}}
    return final_annotators

def filtercol(dd, annot):
    if dd['relation']=='IN':
        return annot + '__' + dd['col'] + ' ' + dd['relation'] + ' ("' + '", "'.join(dd['value'].split(',')) + '")'
    elif dd['relation']=='IS' or dd['relation']=='IS NOT':
        return annot + '__' + dd['col'] + ' ' + dd['relation'] + ' ' + dd['value']
    else:
        return annot + '__'+ dd['col'] + ' ' + dd['relation'] + dd['value']    

def filterunit(annot):
    dd = filter[annot]
    if dd['col'].lower()=='multiple':
        cols = dd['cols'].split(',')
        relations = dd['relation'].split(',')
        values = dd['value'].split(',')
        return(' OR '.join([filtercol({{'col':cols[0], 'relation': relations[0], 'value': values[0]}}, annot) for i in range(len(cols))]))
    else:
        return(filtercol(dd, annot))

def filterunit_null(annot):
    dd = filter[annot]
    if dd['col'].lower()=='multiple':
        cols = dd['cols'].split(',')
        relations = dd['relation'].split(',')
        values = dd['value'].split(',')
        return(' AND '.join([annot + '__' + cols[i] + ' IS NULL' for i in range(len(cols))]))
    else:
        return(annot + '__' + dd['col'] + ' IS NULL')

# Find the intersect of annotators listed
# in colnames of the SQLite variants table 
# and annotators in filter config. Must run
# this step, if a module in OpenCRAVAT does
# not have any annotations for a provided set
# of variants, then that modules annotations 
# may not exist in the SQLite table.
df = pd.read_sql_query("SELECT * FROM variant", conn)
table_var_annotators = set([col for col in df.columns])
filter_annotators = []
column2module = {{}}
for ann in set(filter.keys()):
    try:
        # Multiple column filters
        col_names = filter[ann]['cols']
        col_names = [c.strip() for c in col_names.split(',')]
    except KeyError:
        # One column filter 
        col_names = [filter[ann]['col'].strip()]
    for col in col_names:
        coln = '{{}}__{{}}'.format(ann, col)
        filter_annotators.append(coln)
        column2module[coln] = ann

filter_annotators = set(filter_annotators)
tmp_annotators = table_var_annotators.intersection(filter_annotators)
keep_annotators = set([column2module[ann] for ann in tmp_annotators])

# Sanity check 
if len(keep_annotators) == 0:
    print('WARNING: No filter annotators were provided that match oc run annotators.', file=sys.stderr)
    print('WARNING: The next filtering step may fail.', file=sys.stderr)

# Filter to avoid SQL filtering issues
filter = keep(filter, keep_annotators)
print('Apply final filters to SQLite: ', filter)

filter_query_nonnull = ' OR '.join([filterunit(annot) for annot in filter.keys()])
filter_query_null = ' AND '.join([filterunit_null(annot) for annot in filter.keys()])
filter_query = filter_query_nonnull + ' OR (' + filter_query_null + ')'
print(filter_query)
conn.execute('CREATE TABLE variant2 AS SELECT * FROM variant WHERE (' + filter_query + ')')
conn.execute('DROP TABLE variant')
conn.execute('ALTER TABLE variant2 RENAME TO variant')
conn.execute('DELETE from sample WHERE base__uid NOT IN (SELECT base__uid FROM variant)')
conn.execute('DELETE FROM gene WHERE base__hugo NOT IN (SELECT base__hugo FROM variant)')
conn.execute('DELETE FROM mapping WHERE base__uid NOT IN (SELECT base__uid FROM variant)')
conn.execute('UPDATE info SET colval = (SELECT COUNT(*) FROM variant) WHERE colkey == "Number of unique input variants"')
conn.execute('VACUUM')
conn.close()
EOF

# Create fix column script,
# Fixes columns to a min and max AF 
cp {output.filter_2} {output.fixed}
cat << EOF > {params.fixed}
import sqlite3
import os
import pandas as pd

conn = sqlite3.connect("{output.fixed}")
conn.isolation_level = None
cursor = conn.cursor()
depth = pd.read_sql_query('SELECT base__uid,vcfinfo__tot_reads,vcfinfo__af from variant', conn, index_col = 'base__uid')
tot_read = depth.vcfinfo__tot_reads.str.split(';', expand = True).astype('float')
af = depth.vcfinfo__af.str.split(';', expand = True).apply(pd.to_numeric)
depth['vcfinfo__Max_read'] = tot_read.max(axis = 1)
depth['vcfinfo__Min_read'] = tot_read.min(axis = 1)
depth['vcfinfo__Max_af'] = af.max(axis = 1)
depth['vcfinfo__Min_af'] = af.min(axis = 1)
depth.to_sql('tmp', conn, if_exists = 'replace', index = True)
conn.execute('alter table variant add column vcfinfo__Max_read numeric(50)')
conn.execute('alter table variant add column vcfinfo__Min_read numeric(50)')
conn.execute('alter table variant add column vcfinfo__Max_af numeric(50)')
conn.execute('alter table variant add column vcfinfo__Min_af numeric(50)')
qry = 'update variant set vcfinfo__Max_read = (select vcfinfo__Max_read from tmp where tmp.base__uid = variant.base__uid) where vcfinfo__Max_read is NULL'
conn.execute(qry)
qry = 'update variant set vcfinfo__Min_read = (select vcfinfo__Min_read from tmp where tmp.base__uid = variant.base__uid) where vcfinfo__Min_read is NULL'
conn.execute(qry)
qry = 'update variant set vcfinfo__Max_af = (select vcfinfo__Max_af from tmp where tmp.base__uid = variant.base__uid) where vcfinfo__Max_af is NULL'
conn.execute(qry)
qry = 'update variant set vcfinfo__Min_af = (select vcfinfo__Min_af from tmp where tmp.base__uid = variant.base__uid) where vcfinfo__Min_af is NULL'
conn.execute(qry)
conn.execute('''INSERT INTO variant_header (col_name, col_def) VALUES ('vcfinfo__Max_read','{{"index": null, "name": "vcfinfo__Max_read", "title": "Max reads", "type": "float", "categories": [], "width": 70, "desc": null, "hidden": false, "category": null, "filterable": true, "link_format": null, "genesummary": false, "table": false}}')''')
conn.execute('''INSERT INTO variant_header (col_name, col_def) VALUES ('vcfinfo__Min_read','{{"index": null, "name": "vcfinfo__Min_read", "title": "Min reads", "type": "float", "categories": [], "width": 70, "desc": null, "hidden": false, "category": null, "filterable": true, "link_format": null, "genesummary": false, "table": false}}')''')
conn.execute('''INSERT INTO variant_header (col_name, col_def) VALUES ('vcfinfo__Max_af','{{"index": null, "name": "vcfinfo__Max_af", "title": "Max AF", "type": "float", "categories": [], "width": 70, "desc": null, "hidden": false, "category": null, "filterable": true, "link_format": null, "genesummary": false, "table": false}}')''')
conn.execute('''INSERT INTO variant_header (col_name, col_def) VALUES ('vcfinfo__Min_af','{{"index": null, "name": "vcfinfo__Min_af", "title": "Min AF", "type": "float", "categories": [], "width": 70, "desc": null, "hidden": false, "category": null, "filterable": true, "link_format": null, "genesummary": false, "table": false}}')''')
conn.commit()
conn.execute('drop table tmp')
conn.execute('VACUUM')
conn.close()
EOF

echo 'Running first filtering script'
python3 {params.filter_1}

echo 'Running secondary filtering script'
python3 {params.filter_2}

echo 'Running column fixing script'
python3 {params.fixed}
"""

shell: """
python3 {params.get_flowcell_lanes} \\
    {input.r1} \\
    {wildcards.name} \\
> {output.txt}
"""

shell: """
fastqc -t {threads} \\
    -f bam \\
    --contaminants {params.adapters} \\
    -o {params.outdir} \\
    {input.bam} 
"""

shell: """
samtools flagstat --threads {threads} \\
    {input.bam} \\
> {output.txt}
"""

shell: """
bcftools stats \\
    {input.vcf} \\
> {output.txt}
"""

shell: """
gatk --java-options '-Xmx{params.memory}g -XX:ParallelGCThreads={threads}' VariantEval \\
    -R {params.genome} \\
    -O {output.grp} \\
    --dbsnp {params.dbsnp} \\
    --eval {input.vcf} 
"""

shell: """
java -Xmx{params.memory}g -jar ${{SNPEFF_JAR}} \\
    -v -canon -c {params.config} \\
    -csvstats {output.csv} \\
    -stats {output.html} \\
    {params.genome} \\
    {input.vcf} > {output.vcf}
"""

shell: """
vcftools \\
    --gzvcf {input.vcf} \\
    --het \\
    --out {params.prefix}
"""

shell: """ 
echo "Extracting sites to estimate ancestry."
somalier extract \\
    -d {params.outdir} \\
    --sites {params.sites} \\
    -f {params.genome} \\
    {input.vcf}

# Check if pedigree file exists,
# pulled from patient database
pedigree_option=""
if [ -f "{params.ped}" ]; then
    # Use PED with relate command
    pedigree_option="-p {params.ped}"
fi
echo "Estimating relatedness with pedigree $pedigree_option"
somalier relate "$pedigree_option" \\
    -i -o {params.outdir}/relatedness \\
    {output.somalier}

echo "Estimating ancestry."
somalier ancestry \\
    --n-pcs=10 \\
    -o {params.outdir}/ancestry \\
    --labels {params.ancestry_db}/ancestry-labels-1kg.tsv \\
    {params.ancestry_db}/*.somalier ++ \\
    {output.somalier} || {{
# Somalier ancestry error,
# usually due to not finding
# any sites compared to the 
# its references, expected 
# with sub-sampled datasets
echo "WARNING: Somalier ancestry failed..." 1>&2
touch {output.ancestry}
}}
"""

shell: """
# Create list of chunks to merge
find {params.octopath} -iname '{params.tumor}.vcf.gz' \\
    > {output.lsl}
# Merge octopus chunk calls,
# contains both germline and
# somatic variants
bcftools concat \\
    --threads {threads} \\
    -d exact \\
    -a \\
    -f {output.lsl} \\
    -o {output.raw} \\
    -O v
# Filter Octopus callset for 
# variants with SOMATIC tag
grep -E "#|CHROM|SOMATIC" {output.raw} \\
    > {output.vcf}
"""

shell: """
octopus --threads {threads} \\
    --working-directory {params.wd} \\
    --temp-directory-prefix {params.tmpdir} \\
    -R {params.genome} \\
    -I {input.normal} \\
    -o {output.vcf} \\
    --forest-model {params.model} \\
    --annotations AC AD AF DP \\
    -T {params.chroms}
"""

shell: """
gatk Mutect2 \\
    -R {params.genome} \\
    -I {input.tumor} {params.i_option} {params.normal_option} \\
    --panel-of-normals {params.pon} \\
    --germline-resource {params.germsource} \\
    -L {params.chrom} \\
    -O {output.vcf} \\
    --f1r2-tar-gz {output.orien} \\
    --independent-mates
"""

shell: """
# Setups temporary directory for
# intermediate files with built-in 
# mechanism for deletion on exit
if [ ! -d "{params.tmpdir}" ]; then mkdir -p "{params.tmpdir}"; fi
tmp=$(mktemp -d -p "{params.tmpdir}")
trap 'rm -rf "${{tmp}}"' EXIT

java -Xmx{params.memory}g -Djava.io.tmpdir=${{tmp}} \
    -XX:ParallelGCThreads={threads} -jar $GATK_JAR -T CombineVariants \\
    --use_jdk_inflater --use_jdk_deflater \\
    -R {params.genome} \\
    --filteredrecordsmergetype KEEP_UNCONDITIONAL \\
    --assumeIdenticalSamples \\
    -o {output.vcf} \\
    {params.multi_variant_option}
"""

shell: """
# Gather Mutect2 stats
gatk MergeMutectStats \\
    {params.multi_stats_option} \\
    -O {output.stats} &
# Learn read orientaion model
# for artifact filtering 
gatk LearnReadOrientationModel \\
    --output {output.orien} \\
    {params.multi_orien_option} &
wait
"""

shell: """
gatk --java-options '-Xmx{params.memory}g' GetPileupSummaries \\
    -I {input.tumor} \\
    -V {params.gsnp} \\
    -L {params.gsnp} \\
    -O {output.summary}
"""

shell: """
gatk --java-options '-Xmx{params.memory}g' GetPileupSummaries \\
    -I {input.normal} \\
    -V {params.gsnp} \\
    -L {params.gsnp} \\
    -O {output.summary}
"""

shell: """
gatk CalculateContamination \\
    -I {input.tumor} {params.normal_option} \\
    -O {output.summary}
"""

shell: """
# Mutect2 orien bias filter
gatk FilterMutectCalls \\
    -R {params.genome} \\
    -V {input.vcf} \\
    --ob-priors {input.orien} \\
    --contamination-table {input.summary} \\
    -O {output.vcf} \\
    --stats {input.stats} 
"""

shell: """
# Prefilter and calculate position
# specific summary statistics 
MuSE call \\
    -n {threads} \\
    -f {params.genome} \\
    -O {params.tumor} \\
    {input.tumor} {params.normal_option} 
# Calculate cutoffs from a 
# sample specific error model
MuSE sump \\
    -n {threads} \\
    -G \\
    -I {output.txt} \\
    -O {output.vcf} \\
    -D {params.dbsnp}
# Renaming TUMOR/NORMAL in VCF 
# with real sample names
echo -e "TUMOR\\t{params.rename}{params.normal_header}" \\
> {output.header} 
bcftools reheader \\
    -o {output.final} \\
    -s {output.header} \\
    {output.vcf}
"""

shell: """
# Setups temporary directory for
# intermediate files with built-in 
# mechanism for deletion on exit
if [ ! -d "{params.tmpdir}" ]; then mkdir -p "{params.tmpdir}"; fi
tmp=$(mktemp -d -p "{params.tmpdir}")
trap 'rm -rf "${{tmp}}"' EXIT

# Delete previous attempts output
# directory to ensure hard restart
if [ -d "{params.outdir}" ]; then
    rm -rf "{params.outdir}"
fi

# Configure Strelka somatic workflow
configureStrelkaSomaticWorkflow.py \\
    --referenceFasta {params.genome} \\
    --tumorBam {input.tumor} {params.normal_option} \\
    --runDir {params.outdir} \\
    --callRegions {params.regions}

# Call somatic variants with Strelka
echo "Starting Strelka workflow..."
{params.workflow} \\
    -m local \\
    -j {threads} \\
    -g {params.memory} 

# Combine and filter results
echo "Running CombineVariants..."
java -Xmx{params.memory}g -Djava.io.tmpdir=${{tmp}} \
    -XX:ParallelGCThreads={threads} -jar $GATK_JAR -T CombineVariants \\
    --use_jdk_inflater --use_jdk_deflater \\
    -R {params.genome} \\
    --variant {output.snps} \\
    --variant {output.indels} \\
    --assumeIdenticalSamples \\
    --filteredrecordsmergetype KEEP_UNCONDITIONAL \\
    -o {output.vcf}

# Renaming TUMOR/NORMAL in 
# VCF with real sample names
echo -e "TUMOR\\t{params.tumor}{params.normal_header}" \\
> {output.header} 
bcftools reheader \\
    -o {output.final} \\
    -s {output.header} \\
    {output.vcf}
"""

shell: """
# Normalize VCF prior to SelectVar
# which needs multi-allelic sites
# to be split prior to running 
echo "Running bcftools norm..."
bcftools norm \\
    -c w \\
    -m - \\
    -Ov \\
    --threads {threads} \\
    -f {params.genome} \\
    -o {output.norm} \\
    {input.vcf}
# Remove filtered sites and output
# variants not called in the PON
echo "Running SelectVariants..."
gatk --java-options "-Xmx{params.memory}g" SelectVariants \\
    -R {params.genome} \\
    --variant {output.norm} \\
    --discordance {params.pon} \\
    --exclude-filtered \\
    --output {output.filt}
# Fix format number metadata, gatk 
# SelectVariants converts Number
# metadata incorrectly when it
# it is set to Number=.
sed -i 's/Number=R/Number=./g' \\
    {output.filt}
"""

shell: """
# Filter call set to tumor sites
bcftools view \\
    -c1 \\
    -Oz \\
    -s '{params.sample}' \\
    -o {output.tmp} \\
    {input.vcf}
# Renaming sample name in VCF 
# to contain caller name
echo -e "{params.sample}\\t{params.rename}" \\
> {output.header} 
bcftools reheader \\
    -o {output.tumor} \\
    -s {output.header} \\
    {output.tmp}
# Create an VCF index for intersect
bcftools index \\
    -f \\
    --tbi \\
    {output.tumor} 
"""

shell: """
# Filter call set to normal sites
bcftools view \\
    --force-samples \\
    -c1 \\
    -Oz \\
    -s '{params.sample}' \\
    -o {output.tmp} \\
    {input.vcf}
# Renaming sample name in VCF 
# to contain caller name
echo -e "{params.sample}\\t{params.rename}" \\
> {output.header} 
bcftools reheader \\
    -o {output.normal} \\
    -s {output.header} \\
    {output.tmp}
# Create an VCF index for intersect
bcftools index \\
    -f \\
    --tbi \\
    {output.normal}
"""

shell: """
# Delete previous attempts output
# directory to ensure hard restart
if [ -d "{params.isec_dir}" ]; then
    rm -rf "{params.isec_dir}"
fi
# Intersect somatic callset to find
# variants in at least two callers
bcftools isec \\
    -Oz \\
    -n+2 \\
    -c none \\
    -p {params.isec_dir} \\
    {input.tumors} 
# Create list of files to merge 
find {params.isec_dir} \\
    -name '*.vcf.gz' \\
    | sort \\
> {output.lsl} 
# Merge variants found in at 
# least two callers 
bcftools merge \\
    -Oz \\
    -o {output.merged} \\
    -l {output.lsl}
# Create an VCF index for merge
bcftools index \\
    -f \\
    --tbi \\
    {output.merged}
"""

shell: """
# vcf2maf needs an uncompressed VCF file
zcat {input.vcf} \\
> {output.vcf}
# Run VEP and convert VCF into MAF file
vcf2maf.pl \\
    --input-vcf {output.vcf} \\
    --output-maf {output.maf} \\
    --vep-path ${{VEP_HOME}} \\
    --vep-data {params.vep_data} \\
    --cache-version {params.ref_version} \\
    --ref-fasta {params.genome} \\
    --vep-forks {threads} \\
    --tumor-id {params.tumor} {params.normal_option} \\
    --ncbi-build {params.vep_build} \\
    --species {params.vep_species}
"""

shell: """
echo "Combining MAFs..."
head -2 {input.mafs[0]} > {output.maf}
awk 'FNR>2 {{print}}' {input.mafs} >> {output.maf}
"""

shell: """
Rscript {params.script} \\
    {params.wdir} \\
    {input.maf} \\
    {output.summary} \\
    {output.oncoplot}
"""

shell: """
# SigProfiler input directory must
# only contain input MAF
mkdir -p "{params.wdir}"
ln -sf {input.maf} {params.wdir}
python3 {params.script} \\
    -i {params.wdir}/ \\
    -o {params.odir}/ \\
    -p {params.sample} \\
    -r {params.genome}
"""

shell: """
# Merge SigProfiler PDFs
pdfunite {input.pdfs} \\
    {output.pdf}
"""

shell: """
# Delete previous attempts output
# directory to ensure hard restart
if [ -d "{params.outdir}" ]; then
    rm -rf "{params.outdir}"
fi

# Configure Manta germline SV workflow 
configManta.py \\
    --callRegions {params.regions} \\
    --bam {input.bam} \\
    --referenceFasta {params.genome} \\
    --runDir {params.outdir}

# Call germline SV with Manta workflow
echo "Starting Manta workflow..."
{params.workflow} \\
    -j {threads} \\
    -g {params.memory} 
"""