<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
 <head>
      <title>Cutadapt on ACCESS</title>
      <version>3.4</version>
      <description>Remove adapter sequences from high-throughput sequencing reads</description>
      <authors>Marcel Martin</authors>
      <reference>Marcel Martin (2011) Cutadapt removes adapter sequences from high-throughput sequencing reads. EMBnet.Journal, 17(1):10-12. http://dx.doi.org/10.14806/ej.17.1.200
</reference>
      <category>Assembly:Assemble_reads</category>
      <doclink></doclink>
      <doclink></doclink>
</head>
	
<command>cutadapt_xsede</command>
<!--  basic use: cutadapt -a AACCGGTT -o output.fastq input.fastq
compressed files are ok 

cutadapt -a AACCGGTT -o output.fastq.gz input.fastq.gz
Options:
  -h, -*help            Show this help message and exit
  -*version             Show version number and exit
  -*debug [{trace}]     Print debug log. 'trace' prints also DP matrices
  -j CORES, -*cores CORES
                        Number of CPU cores to use. Use 0 to auto-detect.
                        Default: 1 -->
<!-- cutadapt version 2.10

Copyright (C) 2010-2020 Marcel Martin <marcel.martin@scilifelab.se>

cutadapt removes adapter sequences from high-throughput sequencing reads.

Usage:
    cutadapt -a ADAPTER [options] [-o output.fastq] input.fastq

For paired-end reads:
    cutadapt -a ADAPT1 -A ADAPT2 [options] -o out1.fastq -p out2.fastq in1.fastq in2.fastq

Replace "ADAPTER" with the actual sequence of your 3' adapter. IUPAC wildcard
characters are supported. All reads from input.fastq will be written to
output.fastq with the adapter sequence removed. Adapter matching is
error-tolerant. Multiple adapter sequences can be given (use further -a
options), but only the best-matching adapter will be removed.

Input may also be in FASTA format. Compressed input and output is supported and
auto-detected from the file name (.gz, .xz, .bz2). Use the file name '-' for
standard input/output. Without the -o option, output is sent to standard output.

Citation:

Marcel Martin. Cutadapt removes adapter sequences from high-throughput
sequencing reads. EMBnet.Journal, 17(1):10-12, May 2011.
http://dx.doi.org/10.14806/ej.17.1.200

Run "cutadapt -*help" to see all command-line options.
See https://cutadapt.readthedocs.io/ for full documentation.

Options:
  -h, -*help            Show this help message and exit
  -*version             Show version number and exit
  -*debug [{trace}]     Print debug log. 'trace' prints also DP matrices
  -j CORES, -*cores CORES
                        Number of CPU cores to use. Use 0 to auto-detect.
                        Default: 1

Finding adapters:
  Parameters -a, -g, -b specify adapters to be removed from each read (or
  from the first read in a pair if data is paired). If specified multiple
  times, only the best matching adapter is trimmed (but see the -*times
  option). When the special notation 'file:FILE' is used, adapter sequences
  are read from the given FASTA file.

  -a ADAPTER, -*adapter ADAPTER
                        Sequence of an adapter ligated to the 3' end (paired
                        data: of the first read). The adapter and subsequent
                        bases are trimmed. If a '$' character is appended
                        ('anchoring'), the adapter is only found if it is a
                        suffix of the read.
  -g ADAPTER, -*front ADAPTER
                        Sequence of an adapter ligated to the 5' end (paired
                        data: of the first read). The adapter and any
                        preceding bases are trimmed. Partial matches at the 5'
                        end are allowed. If a '^' character is prepended
                        ('anchoring'), the adapter is only found if it is a
                        prefix of the read.
  -b ADAPTER, -*anywhere ADAPTER
                        Sequence of an adapter that may be ligated to the 5'
                        or 3' end (paired data: of the first read). Both types
                        of matches as described under -a und -g are allowed.
                        If the first base of the read is part of the match,
                        the behavior is as with -g, otherwise as with -a. This
                        option is mostly for rescuing failed library
                        preparations - do not use if you know which end your
                        adapter was ligated to!
  -e RATE, -*error-rate RATE
                        Maximum allowed error rate as value between 0 and 1
                        (no. of errors divided by length of matching region).
                        Default: 0.1 (=10%)
  -*no-indels           Allow only mismatches in alignments. Default: allow
                        both mismatches and indels
  -n COUNT, -*times COUNT
                        Remove up to COUNT adapters from each read. Default: 1
  -O MINLENGTH, -*overlap MINLENGTH
                        Require MINLENGTH overlap between read and adapter for
                        an adapter to be found. Default: 3
  -*match-read-wildcards
                        Interpret IUPAC wildcards in reads. Default: False
  -N, -*no-match-adapter-wildcards
                        Do not interpret IUPAC wildcards in adapters.
  -*action {trim,mask,lowercase,none}
                        What to do with found adapters. mask: replace with 'N'
                        characters; lowercase: convert to lowercase; none:
                        leave unchanged (useful with -*discard-untrimmed).
                        Default: trim
  -*rc, -*revcomp       Check both the read and its reverse complement for
                        adapter matches. If match is on reverse-complemented
                        version, output that one. Default: check only read

Additional read modifications:
  -u LENGTH, -*cut LENGTH
                        Remove bases from each read (first read only if
                        paired). If LENGTH is positive, remove bases from the
                        beginning. If LENGTH is negative, remove bases from
                        the end. Can be used twice if LENGTHs have different
                        signs. This is applied *before* adapter trimming.
  -*nextseq-trim 3'CUTOFF
                        NextSeq-specific quality trimming (each read). Trims
                        also dark cycles appearing as high-quality G bases.
  -q [5'CUTOFF,]3'CUTOFF, -*quality-cutoff [5'CUTOFF,]3'CUTOFF
                        Trim low-quality bases from 5' and/or 3' ends of each
                        read before adapter removal. Applied to both reads if
                        data is paired. If one value is given, only the 3' end
                        is trimmed. If two comma-separated cutoffs are given,
                        the 5' end is trimmed with the first cutoff, the 3'
                        end with the second.
  -*quality-base N      Assume that quality values in FASTQ are encoded as
                        ascii(quality + N). This needs to be set to 64 for
                        some old Illumina FASTQ files. Default: 33
  -*length LENGTH, -l LENGTH
                        Shorten reads to LENGTH. Positive values remove bases
                        at the end while negative ones remove bases at the
                        beginning. This and the following modifications are
                        applied after adapter trimming.
  -*trim-n              Trim N's on ends of reads.
  -*length-tag TAG      Search for TAG followed by a decimal number in the
                        description field of the read. Replace the decimal
                        number with the correct length of the trimmed read.
                        For example, use -*length-tag 'length=' to correct
                        fields like 'length=123'.
  -*strip-suffix STRIP_SUFFIX
                        Remove this suffix from read names if present. Can be
                        given multiple times.
  -x PREFIX, -*prefix PREFIX
                        Add this prefix to read names. Use {name} to insert
                        the name of the matching adapter.
  -y SUFFIX, -*suffix SUFFIX
                        Add this suffix to read names; can also include {name}
  -*zero-cap, -z        Change negative quality values to zero.

Filtering of processed reads:
  Filters are applied after above read modifications. Paired-end reads are
  always discarded pairwise (see also -*pair-filter).

  -m LEN[:LEN2], -*minimum-length LEN[:LEN2]
                        Discard reads shorter than LEN. Default: 0
  -M LEN[:LEN2], -*maximum-length LEN[:LEN2]
                        Discard reads longer than LEN. Default: no limit
  -*max-n COUNT         Discard reads with more than COUNT 'N' bases. If COUNT
                        is a number between 0 and 1, it is interpreted as a
                        fraction of the read length.
  -*max-expected-errors ERRORS, -*max-ee ERRORS
                        Discard reads whose expected number of errors
                        (computed from quality values) exceeds ERRORS.
  -*discard-trimmed, -*discard
                        Discard reads that contain an adapter. Use also -O to
                        avoid discarding too many randomly matching reads.
  -*discard-untrimmed, -*trimmed-only
                        Discard reads that do not contain an adapter.
  -*discard-casava      Discard reads that did not pass CASAVA filtering
                        (header has :Y:).

Output:
  -*quiet               Print only error messages.
  -*report {full,minimal}
                        Which type of report to print: 'full' or 'minimal'.
                        Default: full
  -o FILE, -*output FILE
                        Write trimmed reads to FILE. FASTQ or FASTA format is
                        chosen depending on input. Summary report is sent to
                        standard output. Use '{name}' for demultiplexing (see
                        docs). Default: write to standard output
  -*fasta               Output FASTA to standard output even on FASTQ input.
  -Z                    Use compression level 1 for gzipped output files
                        (faster, but uses more space)
  -*info-file FILE      Write information about each read and its adapter
                        matches into FILE. See the documentation for the file
                        format.
  -r FILE, -*rest-file FILE
                        When the adapter matches in the middle of a read,
                        write the rest (after the adapter) to FILE.
  -*wildcard-file FILE  When the adapter has N wildcard bases, write adapter
                        bases matching wildcard positions to FILE. (Inaccurate
                        with indels.)
  -*too-short-output FILE
                        Write reads that are too short (according to length
                        specified by -m) to FILE. Default: discard reads
  -*too-long-output FILE
                        Write reads that are too long (according to length
                        specified by -M) to FILE. Default: discard reads
  -*untrimmed-output FILE
                        Write reads that do not contain any adapter to FILE.
                        Default: output to same file as trimmed reads

Paired-end options:
  The -A/-G/-B/-U options work like their -a/-b/-g/-u counterparts, but are
  applied to the second read in each pair.

  -A ADAPTER            3' adapter to be removed from second read in a pair.
  -G ADAPTER            5' adapter to be removed from second read in a pair.
  -B ADAPTER            5'/3 adapter to be removed from second read in a pair.
  -U LENGTH             Remove LENGTH bases from second read in a pair.
  -p FILE, -*paired-output FILE
                        Write second read in a pair to FILE.
  -*pair-adapters       Treat adapters given with -a/-A etc. as pairs. Either
                        both or none are removed from each read pair.
  -*pair-filter (any|both|first)
                        Which of the reads in a paired-end read have to match
                        the filtering criterion in order for the pair to be
                        filtered. Default: any
  -*interleaved         Read and/or write interleaved paired-end reads.
  -*untrimmed-paired-output FILE
                        Write second read in a pair to this FILE when no
                        adapter was found. Use with -*untrimmed-output.
                        Default: output to same file as trimmed reads
  -*too-short-paired-output FILE
                        Write second read in a pair to this file if pair is
                        too short. Use also -*too-short-output.
  -*too-long-paired-output FILE
                        Write second read in a pair to this file if pair is
                        too long. Use also -*too-long-output.
 -->




<parameters>
		<parameter ishidden="1" type="String">
          <name>cutadapt_invoke</name>
          <attributes>
<!--            <precond>
          			<language>perl</language>
          			<code>$run_sortsam</code>
          		</precond> -->
          		<format>
          			<language>perl</language>
          			<code>"cutadapt_expanse"</code>
				</format>
				<group>1</group>
			</attributes>
        </parameter>
        
<!-- we need an input file. So this can be any file. It will not be used or called in any way -->       
         <parameter isinput="1" type="InFile">
              <name>infile_placeholder</name>
              <attributes>
<!--               	<precond>
             		<language>perl</language>
             		<code>$compressed_input</code>
             	</precond> -->
             	<group>97</group>
             	<filenames>placeholder.txt</filenames>
              </attributes>
         </parameter>
         
 <!-- uncompressed input command line-->        
         <parameter ishidden="1" type="String">
              <name>infile_notcompressed2</name>
              <attributes>
             	<prompt >Input fasta file</prompt>
             	<group>97</group>
	           	<precond>
             		<language>perl</language>
             		<code>!$compressed_input</code>
             	</precond>    
             	<format>
             		<language>perl</language>
             		<code>"input.fastq"</code>
             	</format>
              </attributes>
         </parameter>

<!-- compressed input command line-->                 
         <parameter ishidden="1" type="String">
              <name>infile_compressed2</name>
              <attributes>
             	<group>97</group>
	           	<precond>
             		<language>perl</language>
             		<code>$compressed_input</code>
             	</precond>    
             	<format>
             		<language>perl</language>
             		<code>"input.fastq.gz"</code>
             	</format>
              </attributes>
         </parameter>
         
         <parameter ishidden="1" type="String">
			<name>cutadapt_scheduler</name>
				<attributes>
					<paramfile>scheduler.conf</paramfile>
					<precond>
						<language>perl</language>
						<code>$num_cores &lt;24</code>
					</precond>
					<format>
						<language>perl</language>
							<code>
									"threads_per_process=$num_cores\\n" .
									"mem=" . (int($num_cores*(248/32))) . "G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
					</format>
					<group>0</group>
				</attributes>
		</parameter>
		
		 <parameter ishidden="1" type="String">
			<name>cutadapt_scheduler2</name>
				<attributes>
					<paramfile>scheduler.conf</paramfile>
					<precond>
						<language>perl</language>
						<code>$num_cores == 24</code>
					</precond>
					<format>
						<language>perl</language>
							<code>
									"threads_per_process=24\\n" .
									"mem=" . (int(24*(248/32))) . "G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
							</code>
					</format>
					<group>0</group>
				</attributes>
		</parameter>
		
		<parameter type="Results">
			<name>allresults</name>
			<attributes>
					<filenames>*</filenames>
			</attributes>
		</parameter>

<!-- Visible parameters -->
<!-- Parameters with visible controls start here -->
		<parameter type="Float" issimple="1" ismandatory="1">
			<name>runtime</name>
			<attributes>
				<group>1</group>
				<paramfile>scheduler.conf</paramfile>
				<prompt>Maximum Hours to Run (click here for help setting this correctly)</prompt>
				<vdef>
					<value>0.25</value>
				</vdef>
				<comment>
<value>Estimate the maximum time your job will need to run. We recommend testimg initially with a &lt; 0.5hr test run because Jobs set for 0.5 h or less depedendably run immediately in the "debug" queue. 
Once you are sure the configuration is correct, you then increase the time. The reason is that jobs &gt; 0.5 h are submitted to the "normal" queue, where jobs configured for 1 or a few hours times may
run sooner than jobs configured for the full 168 hours. 
</value>
				</comment>
				<ctrls>
					<ctrl>
						<message>Maximum Hours to Run must be less than 168</message>
						<language>perl</language>
						<code>$runtime &gt; 168.0</code>
					</ctrl>
					<ctrl>
						<message>Maximum Hours to Run must be greater than 0.1 </message>
						<language>perl</language>
						<code>$runtime &lt; 0.1</code>
					</ctrl>  
				</ctrls>
				<warns>
					<warn>
						<message>The job will run on $num_cores processors as configured. If it runs for the entire configured time, it will consume $num_cores x $runtime cpu hours</message>
						<language>perl</language>
						<code>defined $runtime</code>
					</warn>
				</warns>
				<format>
					<language>perl</language>
					<code>"runhours=$value\\n"</code>
				</format>
			</attributes>
		</parameter>
		
         <parameter issimple="1" type="Integer">
			<name>num_cores</name>
			<attributes>
				<prompt>How many cores?</prompt>
				<group>3</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-j $num_cores":""</code>
				</format>
				<vdef>
					<value>1</value>
				</vdef>
				<ctrls>
					<ctrl>
						<message>The number of cores must be less than or equal to 24</message>
						<language>perl</language>
						<code>$num_cores &gt; 24</code>
					</ctrl>
				</ctrls>
			</attributes>		
        </parameter>
        
       	<parameter issimple="1" type="Switch">
			<name>paired_ends</name>
			<attributes>
				<prompt>I have paired end reads</prompt>
			</attributes>		
        </parameter>
        
       <parameter issimple="1" type="Switch">
			<name>compressed_input</name>
			<attributes>
				<prompt>My input is compressed</prompt>
			</attributes>		
        </parameter> 
        
        <parameter issimple="1" type="InFile">
              <name>infile_compressed</name>
              <attributes>
              	<prompt>Select your first input file (compressed)</prompt>
               	<precond>
             		<language>perl</language>
             		<code>$compressed_input</code>
             	</precond>
             	<group>97</group>
             	<filenames>input.fastq.gz</filenames>
             	<ctrls>
					<ctrl>
						<message>Please select your first input file (compressed)</message>
						<language>perl</language>
						<code>$compressed_input &amp;&amp; !defined $infile_compressed</code>
					</ctrl>
				</ctrls>
              </attributes>
         </parameter>
 
 <!-- uncompressed input -->        
        <parameter issimple="1" type="InFile">
              <name>infile_notcompressed</name>
              <attributes>
              	<prompt>Select your first input file (not compressed)</prompt>
             		<precond>
             		<language>perl</language>
             		<code>!$compressed_input</code>
             	</precond>
             	<group>97</group>
             	<filenames>input.fastq</filenames>
             	<ctrls>
					<ctrl>
						<message>Please select your first input file (not compressed)</message>
						<language>perl</language>
						<code>!$compressed_input &amp;&amp; !defined $infile_notcompressed</code>
					</ctrl>
				</ctrls>
              </attributes>
         </parameter>
                 
         <parameter issimple="1" type="InFile">
			<name>paired_endfilecompr</name>
			<attributes>
				<prompt>Select your second paired end reads file (compressed)</prompt>
				<group>99</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends &amp;&amp; $compressed_input</code>
				</precond>
				<format>
					<language>perl</language>
					<code>"input2.fastq.gz"</code>
				</format>
				<filenames>input2.fastq.gz</filenames>
				<ctrls>
					<ctrl>
						<message>Please select your second paired end reads file (compressed)</message>
						<language>perl</language>
						<code>$paired_ends &amp;&amp; $compressed_input &amp;&amp; !defined $paired_endfilecompr</code>
					</ctrl>
				</ctrls>
			</attributes>		
        </parameter>
         
        <parameter issimple="1" type="InFile">
			<name>paired_endfilenotcompr</name>
			<attributes>
				<prompt>Select your second paired end reads file (not compressed)</prompt>
				<group>99</group>
				<precond>
					<language>perl</language>
					<code>!$compressed_input &amp;&amp; $paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>"input2.fastq"</code>
				</format>
				<filenames>input2.fastq</filenames>
				<ctrls>
					<ctrl>
						<message>Please select your second paired end reads file  (not compressed)</message>
						<language>perl</language>
						<code>$paired_ends &amp;&amp; !$compressed_input &amp;&amp; !defined $paired_endfilenotcompr</code>
					</ctrl>
				</ctrls>
			</attributes>		
        </parameter>
         
<!-- 
Finding adapters:
  Parameters -a, -g, -b specify adapters to be removed from each read (or
  from the first read in a pair if data is paired). If specified multiple
  times, only the best matching adapter is trimmed (but see the _*times
  option). When the special notation 'file:FILE' is used, adapter sequences
  are read from the given FASTA file.

  -a ADAPTER, _*adapter ADAPTER
                        Sequence of an adapter ligated to the 3' end (paired
                        data: of the first read). The adapter and subsequent
                        bases are trimmed. If a '$' character is appended
                        ('anchoring'), the adapter is only found if it is a
                        suffix of the read.-->
                        
           <parameter issimple="1" type="String">
			<name>specify_3adapter</name>
			<attributes>
				<prompt>Enter the 3' adapter</prompt>
				<group>2</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-a $value":""</code>
				</format>
				<comment>
<value> Sequence of an adapter ligated to the 3 end (paired data: of the first read). The adapter and subsequent
bases are trimmed. If a $ character is appended (anchoring), the adapter is only found if it is a suffix of the read.</value>
				</comment>
			</attributes>		
        </parameter> 
<!-- 				for paired end reads   -->
           <parameter issimple="1" type="String">
			<name>specify_3adapterpaired</name>
			<attributes>
				<prompt>Enter the 3' adapter -A for paired-end reads</prompt>
				<group>2</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-A $value":""</code>
				</format>
				<comment>
<value> Sequence of an adapter ligated to the 3 end (paired data: of the first read). The adapter and subsequent
bases are trimmed. If a $ character is appended (anchoring), the adapter is only found if it is a suffix of the read.</value>
				</comment>
			</attributes>		
        </parameter> 
 <!--  -g ADAPTER, _*front ADAPTER
                        Sequence of an adapter ligated to the 5' end (paired
                        data: of the first read). The adapter and any
                        preceding bases are trimmed. Partial matches at the 5'
                        end are allowed. If a '^' character is prepended
                        ('anchoring'), the adapter is only found if it is a
                        prefix of the read.  -->
                        
         <parameter issimple="1" type="String">
			<name>specify_5adapter</name>
			<attributes>
				<prompt>Enter the 5' adapter</prompt>
				<group>2</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-g $value":""</code>
				</format>
				<filenames>5_adapter</filenames>
				<comment>
<value>Sequence of an adapter ligated to the 5 end (paired data: of the first read). The adapter and any preceding bases are trimmed. Partial matches at the 5'
end are allowed. If a ^ character is prepended (anchoring), the adapter is only found if it is a prefix of the read.</value>
				</comment>
			</attributes>		
        </parameter>
        
<!-- for paired end reads -->
		<parameter issimple="1" type="String">
			<name>specify_5adapterpaired</name>
			<attributes>
				<prompt>Enter the 5' adapter for paired end reads (-G)</prompt>
				<group>2</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-G $value":""</code>
				</format>
				<filenames>5_adapter</filenames>
				<comment>
<value>Sequence of an adapter ligated to the 5 end (paired data: of the first read). The adapter and any preceding bases are trimmed. Partial matches at the 5'
end are allowed. If a ^ character is prepended (anchoring), the adapter is only found if it is a prefix of the read.</value>
				</comment>
			</attributes>		
        </parameter>
        
<!--  -b ADAPTER, _*anywhere ADAPTER
                        Sequence of an adapter that may be ligated to the 5'
                        or 3' end (paired data: of the first read). Both types
                        of matches as described under -a und -g are allowed.
                        If the first base of the read is part of the match,
                        the behavior is as with -g, otherwise as with -a. This
                        option is mostly for rescuing failed library
                        preparations - do not use if you know which end your
                        adapter was ligated to!   -->
                        
        <parameter  issimple="1"  type="String">
			<name>specify_anywhichwayadapter</name>
			<attributes>
				<prompt>Enter an adapter that may be 3' or 5'</prompt>
				<group>2</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-b $value":""</code>
				</format>
				<filenames>35_adapter</filenames>
				<comment>
<value>Sequence of an adapter that may be ligated to the 5'or 3' end (paired data: of the first read). Both types of matches as described under -a und -g are allowed.
If the first base of the read is part of the match, the behavior is as with -g, otherwise as with -a. This option is mostly for rescuing failed library
preparations - do not use if you know which end your adapter was ligated to! </value>
				</comment>
			</attributes>		
        </parameter>
        
        <parameter  issimple="1"  type="String">
			<name>specify_anywhichwayadapterpaired</name>
			<attributes>
				<prompt>Enter an adapter that may be 3' or 5' for paired end reads (-B)</prompt>
				<group>2</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-B $value":""</code>
				</format>
				<filenames>35_adapter</filenames>
				<comment>
<value>Sequence of an adapter that may be ligated to the 5'or 3' end (paired data: of the first read). Both types of matches as described under -a und -g are allowed.
If the first base of the read is part of the match, the behavior is as with -g, otherwise as with -a. This option is mostly for rescuing failed library
preparations - do not use if you know which end your adapter was ligated to! </value>
				</comment>
			</attributes>		
        </parameter>
        
<!--   -e RATE, _*error-rate RATE
                        Maximum allowed error rate as value between 0 and 1
                        (no. of errors divided by length of matching region).
                        Default: 0.1 (=10%)  -->
          <parameter issimple="1" type="Float">
			<name>specify_maxerrorrate</name>
			<attributes>
				<prompt>Maximum allowed error rate (-e, --error-rate)</prompt>
				<group>9</group>
				<format>
					<language>perl</language>
					<code>($value ne $vdef) ? "-e $specify_maxerrorrate":""</code>
				</format>
				<vdef>
					<value>0.1</value>
				</vdef>
				<comment>
<value>Maximum allowed error rate as value between 0 and 1 (no. of errors divided by length of matching region). Default: 0.1 (=10%)  </value>
				</comment>
			</attributes>		
        </parameter>
        
<!--   _*no-indels           Allow only mismatches in alignments. Default: allow
                        both mismatches and indels  -->
        <parameter issimple="1" type="Switch">
			<name>only_mismatches</name>
			<attributes>
				<prompt>Allow only mismatches in alignments</prompt>
				<group>11</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--no-indels":""</code>
				</format>
			</attributes>		
        </parameter> 
        
 <!--  -n COUNT, _*times COUNT Remove up to COUNT adapters from each read. Default: 1 -->
         <parameter issimple="1" type="Integer">
			<name>specify_removenadapters</name>
			<attributes>
				<prompt>Remove up to COUNT adapters from each read (-n, --times)</prompt>
				<group>13</group>
				<format>
					<language>perl</language>
					<code>($value ne $vdef) ? "-n $specify_removenadapters":""</code>
				</format>
				<vdef>
					<value>1</value>
				</vdef>
			</attributes>		
        </parameter>
  
<!-- -O MINLENGTH, _*overlap MINLENGTH
                        Require MINLENGTH overlap between read and adapter for
                        an adapter to be found. Default: 3 -->
          <parameter issimple="1" type="Integer">
			<name>overlap_minlength</name>
			<attributes>
				<prompt>Require MINLENGTH overlap between read and adapter (--overlap)</prompt>
				<group>15</group>
				<format>
					<language>perl</language>
					<code>($value ne $vdef) ? "-O $overlap_minlength":""</code>
				</format>
				<vdef>
					<value>3</value>
				</vdef>
				<comment>
<value>Require MINLENGTH overlap between read and adapter for an adapter to be found. (--overlap) Default=3</value>
				</comment>
			</attributes>		
        </parameter>
        
<!--   _*match-read-wildcards
                        Interpret IUPAC wildcards in reads. Default: False  -->
        <parameter issimple="1" type="Switch">
			<name>interpret_wildcards</name>
			<attributes>
				<prompt>Interpret IUPAC wildcards in reads</prompt>
				<group>17</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--match-read-wildcards":""</code>
				</format>
			</attributes>		
        </parameter> 
  
<!--   -N, _*no-match-adapter-wildcards
                        Do not interpret IUPAC wildcards in adapters. --> 
        <parameter issimple="1" type="Switch">
			<name>donot_interpretwildcards</name>
			<attributes>
				<prompt>Do not interpret IUPAC wildcards in adapters.</prompt>
				<group>19</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--no-match-adapter-wildcards":""</code>
				</format>
			</attributes>		
        </parameter> 
  
 <!--  _*action {trim,mask,lowercase,none}
                        What to do with found adapters. mask: replace with 'N'
                        characters; lowercase: convert to lowercase; none:
                        leave unchanged (useful with _*discard-untrimmed).
                        Default: trim -->
        <parameter issimple="1" type="Excl">
			<name>specify_adapterhandling</name>
			<attributes>
				<prompt>What to do with found adapters?</prompt>
				<group>21</group>
				<vlist>
					<value>trim</value>
					<label>Trim</label>
					<value>mask</value>
					<label>Mask</label>
					<value>lowercase</value>
					<label>Lowercase</label>
					<value>none</value>
					<label>None</label>
				</vlist>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--action $value":""</code>
				</format>
				<vdef>
					<value>trim</value>
				</vdef>
			</attributes>		
        </parameter>  
  
 <!--   _*rc, _*revcomp       Check both the read and its reverse complement for
                        adapter matches. If match is on reverse-complemented
                        version, output that one. Default: check only read -->
                        
         <parameter issimple="1" type="Switch">
			<name>check_reversecomp</name>
			<attributes>
				<prompt>Check read AND reverse complement for adapter matches</prompt>
				<group>23</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--rc":""</code>
				</format>
				<comment>
<value> Check both the read and its reverse complement for adapter matches. If match is on reverse-complemented
version, output that one. Default: check only read</value>
				</comment>
			</attributes>		
        </parameter> 
        
			
<parameter type="Paragraph">
	<paragraph>
		<name>additional_readmods</name>
		<prompt>Additional read modifications</prompt>
		<parameters>

<!--  Additional read modifications:
  -u LENGTH, -*cut LENGTH
                        Remove bases from each read (first read only if
                        paired). If LENGTH is positive, remove bases from the
                        beginning. If LENGTH is negative, remove bases from
                        the end. Can be used twice if LENGTHs have different
                        signs. This is applied *before* adapter trimming. -->

          <parameter type="Integer">
			<name>cut_length</name>
			<attributes>
				<prompt>Remove this many bases from each read (-u)</prompt>
				<group>25</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-u $cut_length":""</code>
				</format>
				<comment>
<value>Remove bases from each read (first read only if paired). If LENGTH is positive, remove bases from the
beginning. If LENGTH is negative, remove bases from the end. Can be used twice if LENGTHs have different signs. This is applied *before* adapter trimming</value>
				</comment>
			</attributes>		
        </parameter>
                        
<!--  -*nextseq-trim 3'CUTOFF
                        NextSeq-specific quality trimming (each read). Trims
                        also dark cycles appearing as high-quality G bases.  --> 
          <parameter type="Integer">
			<name>nextseq_trim</name>
			<attributes>
				<prompt>Number of nucleotides removed via NextSeq-specific quality trimming (each read; --nextseq-trim).</prompt>
				<group>27</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--nextseq-trim=$value":""</code>
				</format>
				<comment>
<value>NextSeq-specific quality trimming (each read). Trims also dark cycles appearing as high-quality G bases. </value>
				</comment>
			</attributes>		
        </parameter>
                     
 <!-- -q [5'CUTOFF,]3'CUTOFF, -*quality-cutoff [5'CUTOFF,]3'CUTOFF
                        Trim low-quality bases from 5' and/or 3' ends of each
                        read before adapter removal. Applied to both reads if
                        data is paired. If one value is given, only the 3' end
                        is trimmed. If two comma-separated cutoffs are given,
                        the 5' end is trimmed with the first cutoff, the 3'
                        end with the second.  --> 
         <parameter type="String">
			<name>quality_cutoff</name>
			<attributes>
				<prompt>Trim low-quality bases from 5' and/or 3' ends  -q ([5',]3prime).</prompt>
				<group>27</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-q $value":""</code>
				</format>
				<comment>
<value>Trim low-quality bases from 5 and/or 3 ends of each read before adapter removal. Applied to both reads if
data is paired. If one value is given, only the 3 end is trimmed. If two comma-separated cutoffs are given,
the 5 end is trimmed with the first cutoff, the 3 end with the second. </value>
				</comment>
			</attributes>		
        </parameter>                      
                        
<!-- -*quality-base N  Assume that quality values in FASTQ are encoded as ascii(quality + N). This needs to be set to 64 for
some old Illumina FASTQ files. Default: 33  -->  
         <parameter type="Integer">
			<name>quality_base</name>
			<attributes>
				<prompt>Assume that quality values in FASTQ are encoded as ascii (quality + N)</prompt>
				<group>27</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--quality-base $value":""</code>
				</format>
				<vdef>
					<value>33</value>
				</vdef>
				<comment>
<value>Assume that quality values in FASTQ are encoded as ascii(quality + N). This needs to be set to 64 for
some old Illumina FASTQ files. Default: 33  </value>
				</comment>
			</attributes>		
        </parameter> 
                        
<!--   -*length LENGTH, -l LENGTH
                        Shorten reads to LENGTH. Positive values remove bases
                        at the end while negative ones remove bases at the
                        beginning. This and the following modifications are
                        applied after adapter trimming. -->
         <parameter type="Integer">
			<name>specify_length</name>
			<attributes>
				<prompt>Shorten reads to LENGTH (-l, --length)</prompt>
				<group>29</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-l $value":""</code>
				</format>
				<comment>
<value>Shorten reads to LENGTH. Positive values remove bases at the end while negative ones remove bases at the
beginning. This and the following modifications are applied after adapter trimming. </value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--   -*trim-n              Trim N's on ends of reads. --> 
         <parameter type="Switch">
			<name>specify_trimn</name>
			<attributes>
				<prompt>Trim N's on ends of reads. (--trim-n)</prompt>
				<group>29</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--trim-n":""</code>
				</format>
			</attributes>		
        </parameter> 

<!--   -*length-tag TAG      Search for TAG followed by a decimal number in the
                        description field of the read. Replace the decimal
                        number with the correct length of the trimmed read.
                        For example, use -*length-tag 'length=' to correct
                        fields like 'length=123'. --> 
         <parameter type="String">
			<name>specify_lengthtag</name>
			<attributes>
				<prompt>Search for TAG followed by a decimal number (--length-tag)</prompt>
				<group>31</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--length-tag $value":""</code>
				</format>
				<comment>
<value>Search for TAG followed by a decimal number in the description field of the read. Replace the decimal
number with the correct length of the trimmed read.For example, use --length-tag 'length=' to correct fields like 'length=123'. </value>
				</comment>
			</attributes>		
        </parameter> 
                        
<!-- -*strip-suffix STRIP_SUFFIX Remove this suffix from read names if present. Can be
given multiple times.  --> 
         <parameter type="String">
			<name>specify_stripsuffix</name>
			<attributes>
				<prompt> Remove this suffix from read names if present (--strip-suffix)</prompt>
				<group>31</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--strip-suffix $value":""</code>
				</format>
			</attributes>		
        </parameter> 
         
 <!--  -x PREFIX, -*prefix PREFIX Add this prefix to read names. Use {name} to insert
the name of the matching adapter.  -->
         <parameter type="String">
			<name>specify_addprefix</name>
			<attributes>
				<prompt>Add this prefix to read names (-x)</prompt>
				<group>31</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-x $value":""</code>
				</format>
			</attributes>		
        </parameter> 
        
<!--   -y SUFFIX, -*suffix SUFFIX; Add this suffix to read names; can also include {name}  -->
         <parameter type="String">
			<name>specify_addsuffix</name>
			<attributes>
				<prompt>Add this suffix to read names (-y)</prompt>
				<group>31</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-y $value":""</code>
				</format>
			</attributes>	
        </parameter> 
                        
<!--   -*zero-cap, -z Change negative quality values to zero. -->
         <parameter type="Switch">
			<name>specify_negtozero</name>
			<attributes>
				<prompt>Change negative quality values to zero (-z)</prompt>
				<group>31</group>
				<format>
					<language>perl</language>
					<code>($value) ? "-z":""</code>
				</format>
			</attributes>		
        </parameter>
        
        </parameters> 
	</paragraph>
</parameter>        

<parameter type="Paragraph">
	<paragraph>
		<name>filtering_processedreads</name>
		<prompt>Filtering of processed reads</prompt>
		<parameters>
<!--
Filtering of processed reads:
Filters are applied after above read modifications. Paired-end reads are
always discarded pairwise (see also _*pair-filter).

  -m LEN[:LEN2], _*minimum-length LEN[:LEN2]
                        Discard reads shorter than LEN. Default: 0 -->
         <parameter type="Integer">
			<name>specify_discardlength</name>
			<attributes>
				<prompt>Discard reads shorter than LEN (-m; minimum)</prompt>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<group>55</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-m $value":""</code>
				</format>
			</attributes>		
        </parameter>  
                               
<!--   -M LEN[:LEN2], _*maximum-length LEN[:LEN2] Discard reads longer than LEN. Default: no limit --> 
          <parameter type="Integer">
			<name>specify_maxdiscardlength</name>
			<attributes>
				<prompt>Discard reads longer than LEN (-M; maximum)</prompt>
				<group>57</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-M $value":""</code>
				</format>
			</attributes>		
        </parameter>
                                
<!-- _*max-n COUNT         Discard reads with more than COUNT 'N' bases. If COUNT
                        is a number between 0 and 1, it is interpreted as a
                        fraction of the read length.   -->
         <parameter type="Integer">
			<name>specify_maxnbases</name>
			<attributes>
				<prompt> Discard reads with more than COUNT 'N' bases. (--max-n)</prompt>
				<group>59</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--max-n $value":""</code>
				</format>
				<comment>
<value>Discard reads with more than COUNT 'N' bases. If COUNT is a number between 0 and 1, it is interpreted as a
fraction of the read length.  </value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--   _*max-expected-errors ERRORS, _*max-ee ERRORS
                        Discard reads whose expected number of errors
                        (computed from quality values) exceeds ERRORS. --> 
         <parameter type="Integer">
			<name>discard_maxerrs</name>
			<attributes>
				<prompt>Discard reads whose expected number of errors exceeds (--max-expected-errors)</prompt>
				<group>61</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--max-expected-errors $value":""</code>
				</format>
				<comment>
<value>Discard reads whose expected number of errors (computed from quality values) exceeds ERRORS</value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--    _*discard-trimmed, _*discard   Discard reads that contain an adapter. Use also -O to
avoid discarding too many randomly matching reads. -->
         <parameter type="Switch">
			<name>discard_trimmed</name>
			<attributes>
				<prompt>Discard reads that contain an adapter (--discard-trimmed)</prompt>
				<group>63</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--discard-trimmed":""</code>
				</format>
				<comment>
<value>Discard reads that contain an adapter. Use also -O to avoid discarding too many randomly matching read</value>
				</comment>
			</attributes>		
        </parameter> 
        
<!-- _*discard-untrimmed, _*trimmed-only  Discard reads that do not contain an adapter. -->
         <parameter type="Switch">
			<name>discard_untrimmed</name>
			<attributes>
				<prompt>Discard untrimmed reads (--discard-untrimmed)</prompt>
				<group>65</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--discard-untrimmed":""</code>
				</format>
				<comment>
<value>Discard reads that do not contain an adapter.</value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--  _*discard-casava      Discard reads that did not pass CASAVA filtering
                        (header has :Y:).
-->	
         <parameter type="Switch">
			<name>discard_casava</name>
			<attributes>
				<prompt>Discard reads that did not pass CASAVA filtering (--discard-casava)</prompt>
				<group>67</group>
				<precond>
					<language>perl</language>
					<code>!$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--discard-casava":""</code>
				</format>
				<comment>
<value>Search for TAG followed by a decimal number in the description field of the read. Replace the decimal
number with the correct length of the trimmed read.For example, use --length-tag 'length=' to correct fields like 'length=123'. </value>
				</comment>
			</attributes>		
        </parameter>
        
      </parameters>
   </paragraph>
</parameter>
       

<parameter type="Paragraph">
	<paragraph>
		<name>filtering_pairedreads</name>
		<prompt>Filtering of paired end reads</prompt>
		<parameters>        
  
         <parameter type="String">
			<name>specify_paireddiscardlength</name>
			<attributes>
				<prompt>Discard paired end reads shorter than LEN (-m, --minimum-length LEN:LEN )</prompt>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<group>55</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-m $value":""</code>
				</format>
				<comment>
<value> When trimming paired-end reads, the minimum lengths for R1 and R2 can be specified separately by separating them with a colon (:). If the colon syntax is not used, the same minimum length applies to both reads, as discussed above. Also, one of the values can be omitted to impose no restrictions. For example, with -m 17:, the length of R1 must be at least 17, but the length of R2 is ignored.</value>
				</comment>
			</attributes>		
        </parameter>  
                               
<!--   -M LEN[:LEN2], _*maximum-length LEN[:LEN2] Discard reads longer than LEN. Default: no limit --> 
          <parameter type="String">
			<name>specify_pairedmaxlength</name>
			<attributes>
				<prompt>Discard paired end reads longer than LEN (-M, --maximum-length LEN:LEN )</prompt>
				<group>57</group>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-M $value":""</code>
				</format>
				<comment>
<value> When trimming paired-end reads, the maximum lengths for R1 and R2 can be specified separately by separating them with a colon (:). If the colon syntax is not used, the same minimum length applies to both reads, as discussed above. Also, one of the values can be omitted to impose no restrictions. For example, with -m 17:, the length of R1 must be at least 17, but the length of R2 is ignored.</value>
				</comment>
			</attributes>		
        </parameter>
        
<!-- 		These are the paired-end specific filtering and output options: -*pair-filter=(any|both|first)
Which of the reads in a paired-end read have to match the filtering criterion in order for it to be filtered.
Note that the option names can be abbreviated as long as it is clear which option is meant (unique prefix). For example, 
instead of -*untrimmed-output and -*untrimmed-paired-output, you can write -*untrimmed-o and -*untrimmed-p. -->       				
		 <parameter type="Excl">
			<name>specify_pairedreadfilter</name>
			<attributes>
				<prompt>Which reads in paired-end read have to match the filtering criterion (--discard-casava)</prompt>
				<group>67</group>
					<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<vlist>
					<value>any</value>
					<label>any</label>
					<value>both</value>
					<label>both</label>
					<value>first</value>
					<label>first </label>
				</vlist>
				<format>
					<language>perl</language>
					<code>($value) ? "--pair-filter=$value":""</code>
				</format>
				<comment>
<value>Which of the reads in a paired-end read have to match the filtering criterion in order for it to be filtered. </value>
				</comment>
			</attributes>		
        </parameter> 
       
		</parameters>
	</paragraph>
</parameter>
        
  <parameter type="Paragraph">
	<paragraph>
		<name>output_options</name>
		<prompt>Output options</prompt>
		<parameters>
<!--
Output:
  _*quiet               Print only error messages. -->
  
<!--    _*report {full,minimal}
                        Which type of report to print: 'full' or 'minimal'.
                        Default: full -->
         <parameter type="Switch">
			<name>specify_fullreport</name>
			<attributes>
				<prompt>Print full report (unchecked gives minimal)</prompt>
				<group>81</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--report full":"--report minimal"</code>
				</format>
			</attributes>		
        </parameter> 
        
<!--   -o FILE, _*output FILE
                        Write trimmed reads to FILE. FASTQ or FASTA format is
                        chosen depending on input. Summary report is sent to
                        standard output. Use '{name}' for demultiplexing (see
                        docs). Default: write to standard output --> 
         <parameter type="String">
			<name>specify_outputfile</name>
			<attributes>
				<prompt>Write trimmed reads to FILE (-o)</prompt>
				<group>81</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-o $value":""</code>
				</format>
				<ctrls>
					<ctrl>
						<message>Please enter a name for the trimmed reads output file</message>
						<language>perl</language>
						<code>!defined $specify_outputfile</code>
					</ctrl>
				</ctrls>
				<comment>
<value> Write trimmed reads to FILE. FASTQ or FASTA format is chosen depending on input. Summary report is sent to
standard output. Use '{name}' for demultiplexing (see docs). Default: write to standard output</value>
				</comment>
			</attributes>		
        </parameter> 
        
        <parameter type="String">
			<name>specify_pairedoutputfile</name>
			<attributes>
				<prompt>Write trimmed paired end reads to FILE (-p)</prompt>
				<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<group>81</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-p $value":""</code>
				</format>
				<ctrls>
					<ctrl>
						<message>Please enter a name for the second paired end trimmed reads output file</message>
						<language>perl</language>
						<code>$paired_ends &amp;&amp; !defined $specify_pairedoutputfile</code>
					</ctrl>
				</ctrls>
				<comment>
<value> Write trimmed reads to FILE. FASTQ or FASTA format is chosen depending on input. Summary report is sent to
standard output. Use '{name}' for demultiplexing (see docs). Default: write to standard output</value>
				</comment>
			</attributes>		
        </parameter>
                        
<!--   _*fasta               Output FASTA to standard output even on FASTQ input.  -->
         <parameter type="Switch">
			<name>specify_fastaout</name>
			<attributes>
				<prompt>Output FASTA to standard output even on FASTQ input (--fasta)</prompt>
				<group>83</group>
				<format>
					<language>perl</language>
					<code>($value) ? "--fasta":""</code>
				</format>
			</attributes>		
        </parameter> 
        
<!--   -Z  Use compression level 1 for gzipped output files (faster, but uses more space) -->
         <parameter type="Switch">
			<name>specify_compression</name>
			<attributes>
				<prompt>Use compression level 1 for gzipped output files (-Z)</prompt>
				<group>85</group>
				<format>
					<language>perl</language>
					<code>($value) ? "-Z":""</code>
				</format>
				<comment>
<value> Use compression level 1 for gzipped output files (faster, but uses more space) </value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--    _*info-file FILE      Write information about each read and its adapter
                        matches into FILE. See the documentation for the file
                        format. -->
          <parameter type="String">
			<name>specify_infofile</name>
			<attributes>
				<prompt>Write information about each read and its adapter matches into FILE (--info-file)</prompt>
				<group>87</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--info-file $value":""</code>
				</format>
				<comment>
<value>Write information about each read and its adapter matches into FILE. See the documentation for the file </value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--   -r FILE, _*rest-file FILE
                        When the adapter matches in the middle of a read,
                        write the rest (after the adapter) to FILE.  -->
          <parameter type="String">
			<name>specify_restfile</name>
			<attributes>
				<prompt>Write information about each read and its adapter matches into FILE (-r)</prompt>
				<group>89</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-r $value":""</code>
				</format>
				<comment>
<value>When the adapter matches in the middle of a read, write the rest (after the adapter) to FILE.</value>
				</comment>
			</attributes>		
        </parameter>        
                         
<!--   _*wildcard-file FILE  When the adapter has N wildcard bases, write adapter
                        bases matching wildcard positions to FILE. (Inaccurate
                        with indels.) 
          <parameter type="String">
			<name>specify_wildcardfile</name>
			<attributes>
				<prompt>When the adapter has N wildcard bases, write adapter bases matching wildcard positions to FILE. (-r)</prompt>
				<group>89</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "-r $value":""</code>
				</format>
				<comment>
<value>When the adapter matches in the middle of a read, write the rest (after the adapter) to FILE.</value>
				</comment>
			</attributes>		
        </parameter> -->
        
<!--   _*too-short-output FILE
                        Write reads that are too short (according to length
                        specified by -m) to FILE. Default: discard reads  -->
          <parameter type="String">
			<name>specify_tooshortfile</name>
			<attributes>
				<prompt>Write reads that are too short into FILE (--too-short-output)</prompt>
				<group>89</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--too-short-output $value":""</code>
				</format>
				<comment>
<value>Write reads that are too short (according to length specified by -m) to FILE. Default: discard reads </value>
				</comment>
			</attributes>		
        </parameter>  
        
<!-- -*too-short-paired-output FILE
    Write the second read in a pair to this file if pair is too short. Use together with -*too-short-output.  -->
		 <parameter type="Switch">
			<name>specify_untooshortpairedreadoutfile</name>
			<attributes>
				<prompt>Write the second read in a pair to this file if pair is too short (--too-short-paired-output)</prompt>
				<group>67</group>
					<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--untrimmed-paired-output too-short-paired-output.txt":""</code>
				</format>
				<filenames>too-short-paired-output.txt</filenames>
				<comment>
<value>Write the second read in a pair to this file if pair is too short. Use together with --too-short-output.</value>
				</comment>
			</attributes>		
        </parameter> 
                                
<!--   _*too-long-output FILE
                        Write reads that are too long (according to length
                        specified by -M) to FILE. Default: discard reads  -->
          <parameter type="String">
			<name>specify_toolongfile</name>
			<attributes>
				<prompt>Write reads that are too long into FILE (--too-long-output)</prompt>
				<group>89</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--too-long-output $value":""</code>
				</format>
				<comment>
<value> Write reads that are too long (according to length specified by -M) to FILE. Default: discard reads</value>
				</comment>
			</attributes>		
        </parameter>
        
<!-- -*too-long-paired-output FILE
    Write the second read in a pair to this file if pair is too long. Use together with -*too-long-output. -->
    	<parameter type="Switch">
			<name>specify_toolongpairedreadoutfile</name>
			<attributes>
				<prompt>Write too long second reads to a file (--toolong-paired-output)</prompt>
				<group>67</group>
					<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--too-long-paired-output toolong_paired_outfile.txt":""</code>
				</format>
				<filenames>toolong_paired_outfile.txt</filenames>
				<comment>
<value>Search for TAG followed by a decimal number in the description field of the read. Replace the decimal
number with the correct length of the trimmed read.For example, use --length-tag 'length=' to correct fields like 'length=123'. </value>
				</comment>
			</attributes>		
        </parameter> 
        
<!--  _*untrimmed-output FILE
                        Write reads that do not contain any adapter to FILE.
                        Default: output to same file as trimmed reads -->
          <parameter type="String">
			<name>specify_untrimmedfile</name>
			<attributes>
				<prompt>Write reads that do not contain any adapter into FILE (--too-untrimmed-output)</prompt>
				<group>89</group>
				<format>
					<language>perl</language>
					<code>(defined $value) ? "--too-untrimmed-output $value":""</code>
				</format>
				<comment>
<value>Write reads that do not contain any adapter to FILE Default: discard reads</value>
				</comment>
			</attributes>		
        </parameter>
        
<!-- -*untrimmed-paired-output FILE
Used together with -*untrimmed-output. The second read in a pair is written to this file when the 
    processed pair was not trimmed. -->
		 <parameter type="Switch">
			<name>specify_untrimmedpairedreadoutfile</name>
			<attributes>
				<prompt>Write paired reads that do not contain any adapter into a file (--untrimmed-paired-output)</prompt>
				<group>67</group>
					<precond>
					<language>perl</language>
					<code>$paired_ends</code>
				</precond>
				<format>
					<language>perl</language>
					<code>($value) ? "--untrimmed-paired-output untrimmed_paired_outfile.txt":""</code>
				</format>
				<filenames>untrimmed_paired_outfile.txt</filenames>
			</attributes>		
        </parameter> 

		</parameters>
	</paragraph>
</parameter>

</parameters> 
</pise>