options = tabwidth,indent,style,linewidth,import,verbose,lvt,inner,anonymous,push,pretty,decrypt,onetime,immediate,verify,contrafo,debug

tabwidth.0=<n>
tabwidth.1=Set tab width to n.
tabwidth.2=This means that Jode uses tabs to replace n spaces.  \
Don't confound this with the indent option.  Use 0 if you don't want \
tabs.  Default is 8.

indent.0=<n>
indent.1=Indent blocks by n spaces.

style.0={sun|gnu}
style.1=Specify indentation style.

linewidth.0=<n>
linewidth.1=Set maximum line width to n.
linewidth.2=Jode breaks lines that are longer than this.  It tries it's best \
to make all lines fit in this limit, but sometimes this won't succeed.

import.0=<pkglimit>,<clslimit>
import.1=import classes if they occur more than clslimit times and packages \
with more than pkglimit used classes.  Default is 0,1 which means that all \
used classes are imported, but never a whole package.

verbose.0=<n>
verbose.1=Be verbose (higher n means more verbose).
verbose.2=This prints some information about the currently decompiled \
class or method to the console.

debug.0=<flag>,...
debug.1=Enable debugging options.  Useful to track errors in the decompiler.
debug.2=Possible flags are: \
"bytecode", to print raw bytecode. \
"lvt", dump LocalVariableTable. \
"verifier", to trace bytecode verification. \
"check", do time consuming sanity checks; useful to spot serious errors. \
"types", to see the type intersections. \
"flow", for a very verbose trace of the decompile process. \
"analyze", briefly inform about "T1/T2" analyzation. \
"inout", to view the in/out local variable analyzation. \
"locals", to see how local variable merging is done. \
"constructors", to trace constructor transformation. \
"interpreter", to follow the execution of the interpreter \
(the interpreter is used for string decryption).

inner.0={yes|no}
inner.1=(Don't) decompiler inner classes.

anonymous.0={yes|no}
anonymous.1=(Don't) decompiler method scoped classes.

contrafo.0={yes|no}
contrafo.1=(Don't) transform constructors.

lvt.0={yes|no}
lvt.1=(Don't) use the local variable table.
lvt.2=Turning it off is useful if an obfuscator filled it with bogus values.

pretty.0={yes|no}
pretty.1=(Don't) use `pretty' names for local variables.
pretty.2=The non pretty names have the advantage, that their names are \
unique. This make search & replace possible.

push.0={yes|no}
push.1=Allow PUSH pseudo instructions in output.
push.2=Sometimes, when methods were inlined, Jode can't reconstruct  \
the original expression.  It has to split a complex expression into \
several ones, using temporary variables.   If this option is on, it won't \
use the temporary variables, but uses pseudo PUSH/POP instructions instead, \
as they are in the bytecode.

decrypt.0={yes|no}
decrypt.1=(Don't) decrypt encrypted strings.
decrypt.2=Some obfuscators encrypt all strings.  To decrypt them at runtime \
they add a small decryption routine to the code.  If Jode detects such a \
decryption routine it interprets it to decrypt the strings at decompile time.

onetime.0={yes|no}
onetime.1=(Don't) remove locals that written and then immediately read.
onetime.2=When javac inlines a method it uses temporary local variables for \
the parameters.  Often these local variables can be removed, which makes \
the code much better to read. 

immediate.0={yes|no}
immediate.1=Output the source immediately as it gets decompiled.
immediate.2=This leads to more instant output, but has many disadvantages.\
For one the import statements can't be correct.  But it also may lead to \
buggy code.  The advantage is, that you can get partial output even if an
exception is thrown.

verify.0={yes|no}
verify.1=(Don't) verify code before decompiling it.
verify.2=Jode assumes at many places that your byte code is legal.  To \
be sure it verifies it before decompiling.  If verification fails it \
rejects the code.  Since verification can fail for legal code if the \
type hierarchy is not known, you can turn this option off.