Serialized Form (Stanford JavaNLP API)

Package edu.stanford.nlp.graph
- Class edu.stanford.nlp.graph.DirectedMultiGraph extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  609823567298345145L
  - Serialized Fields
    - outgoingEdges
```
java.util.Map<K,V> outgoingEdges
```
    - incomingEdges
```
java.util.Map<K,V> incomingEdges
```
Package edu.stanford.nlp.international.arabic
- Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable
  
  serialVersionUID:
  
  4448045447200922076L
- Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification.ArabicMorphoFeatures extends MorphoFeatures implements Serializable
  
  serialVersionUID:
  
  -4611776415583633186L
- Class edu.stanford.nlp.international.arabic.Buckwalter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4351710914246859336L
  - Serialized Fields
    - outputUnicodeValues
```
boolean outputUnicodeValues
```
      If true (include flag "-o"), outputs space separated unicode values (e.g., "ء" rather than the character version of those values. Only applicable for Buckwalter to Arabic conversion.
    - arabicChars
```
char[] arabicChars
```
    - buckChars
```
char[] buckChars
```
    - unicode2Buckwalter
```
boolean unicode2Buckwalter
```
    - u2bMap
```
java.util.Map<K,V> u2bMap
```
    - b2uMap
```
java.util.Map<K,V> b2uMap
```
    - unmappable
```
ClassicCounter<E> unmappable
```

Package edu.stanford.nlp.international.arabic.pipeline

Class edu.stanford.nlp.international.arabic.pipeline.DefaultLexicalMapper extends java.lang.Object implements Serializable

serialVersionUID:: -3798804368296999785L

Serialized Fields

utf8ArabicChart
```
java.util.regex.Pattern utf8ArabicChart
```
bwAlefChar
```
java.lang.String bwAlefChar
```
bwDiacritics
```
java.util.regex.Pattern bwDiacritics
```
bwTatweel
```
java.util.regex.Pattern bwTatweel
```
bwAlef
```
java.util.regex.Pattern bwAlef
```
bwQuran
```
java.util.regex.Pattern bwQuran
```

bwNullAnaphoraMarker

java.util.regex.Pattern bwNullAnaphoraMarker

latinPunc
```
java.util.regex.Pattern latinPunc
```
arabicPunc
```
java.util.regex.Pattern arabicPunc
```
arabicDigit
```
java.util.regex.Pattern arabicDigit
```
utf8Diacritics
```
java.util.regex.Pattern utf8Diacritics
```
utf8Tatweel
```
java.util.regex.Pattern utf8Tatweel
```
utf8Alef
```
java.util.regex.Pattern utf8Alef
```
utf8Quran
```
java.util.regex.Pattern utf8Quran
```
utf8ProDrop
```
java.util.regex.Pattern utf8ProDrop
```

segmentationMarker

java.util.regex.Pattern segmentationMarker

morphemeBoundary

java.util.regex.Pattern morphemeBoundary

hasDigit
```
java.util.regex.Pattern hasDigit
```
useATBVocalizedSectionMapping
```
boolean useATBVocalizedSectionMapping
```
stripMorphemeMarkersInUTF8
```
boolean stripMorphemeMarkersInUTF8
```
stripSegmentationMarkersInUTF8
```
boolean stripSegmentationMarkersInUTF8
```
parentTagString
```
java.lang.String parentTagString
```
parentTagsToEscape
```
java.util.Set<E> parentTagsToEscape
```
utf8CliticString
```
java.lang.String utf8CliticString
```
bwClitics
```
java.util.Set<E> bwClitics
```

Package edu.stanford.nlp.international.arabic.process
- Class edu.stanford.nlp.international.arabic.process.ArabicTokenizer.ArabicTokenizerFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
java.util.Properties lexerProperties
```
Package edu.stanford.nlp.international.french
- Class edu.stanford.nlp.international.french.FrenchMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable
  
  serialVersionUID:
  
  -58379347760106784L
Package edu.stanford.nlp.international.french.process
- Class edu.stanford.nlp.international.french.process.FrenchTokenizer.FrenchTokenizerFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
java.util.Properties lexerProperties
```
Package edu.stanford.nlp.international.morph
- Class edu.stanford.nlp.international.morph.MorphoFeatures extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -3893316324305154940L
  - Serialized Fields
    - fSpec
```
java.util.Map<K,V> fSpec
```
    - altTag
```
java.lang.String altTag
```
- Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5720683653931585664L
  - Serialized Fields
    - activeFeatures
```
java.util.Set<E> activeFeatures
```
Package edu.stanford.nlp.io
- Class edu.stanford.nlp.io.RuntimeIOException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -8572218999165094626L

Package edu.stanford.nlp.io.ui

Class edu.stanford.nlp.io.ui.OpenPageDialog extends javax.swing.JDialog implements Serializable

serialVersionUID:: -7987625449997527926L

Serialized Fields

jfc
```
javax.swing.JFileChooser jfc
```
status
```
int status
```
urlTextField
```
javax.swing.JTextField urlTextField
```
openButton
```
javax.swing.JButton openButton
```
jLabel1
```
javax.swing.JLabel jLabel1
```
jPanel3
```
javax.swing.JPanel jPanel3
```
jLabel2
```
javax.swing.JLabel jLabel2
```
jPanel2
```
javax.swing.JPanel jPanel2
```
cancelButton
```
javax.swing.JButton cancelButton
```
browseButton
```
javax.swing.JButton browseButton
```
jPanel1
```
javax.swing.JPanel jPanel1
```

Package edu.stanford.nlp.ling
- Class edu.stanford.nlp.ling.BasicDocument extends java.util.ArrayList<Word> implements Serializable
  
  serialVersionUID:
  
  -24171720584352262L
  - Serialized Fields
    - title
```
java.lang.String title
```
      title of this document (never null).
    - originalText
```
java.lang.String originalText
```
      original text of this document (may be null).
    - labels
```
java.util.List<E> labels
```
      Label(s) for this document.
    - tokenizerFactory
```
TokenizerFactory<T> tokenizerFactory
```
      TokenizerFactory used to convert the text into words inside BasicDocument.parse(String).
- Class edu.stanford.nlp.ling.CategoryWordTag extends StringLabel implements Serializable
  
  serialVersionUID:
  
  -745085381666943254L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.CoreLabel extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.ling.IndexedWord extends CoreLabel implements Serializable
  
  serialVersionUID:
  
  3739633991145239829L
- Class edu.stanford.nlp.ling.LabeledWord extends Word implements Serializable
  
  serialVersionUID:
  
  -7252006452127051085L
  - Serialized Fields
    - tag
```
Label tag
```
- Class edu.stanford.nlp.ling.StringLabel extends ValueLabel implements Serializable
  
  serialVersionUID:
  
  -4153619273767524247L
  - Serialized Fields
    - str
```
java.lang.String str
```
    - beginPosition
```
int beginPosition
```
      Start position of the word in the original input string
    - endPosition
```
int endPosition
```
      End position of the word in the original input string
- Class edu.stanford.nlp.ling.Tag extends StringLabel implements Serializable
  
  serialVersionUID:
  
  1143434026005416755L
- Class edu.stanford.nlp.ling.TaggedWord extends Word implements Serializable
  
  serialVersionUID:
  
  -7252006452127051085L
  - Serialized Fields
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.ValueLabel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1413303679077285530L
- Class edu.stanford.nlp.ling.Word extends StringLabel implements Serializable
  
  serialVersionUID:
  
  -4817252915997034058L
- Class edu.stanford.nlp.ling.WordLemmaTag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5993410244163988138L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - lemma
```
java.lang.String lemma
```
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.WordTag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1859527239216813742L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - tag
```
java.lang.String tag
```
Package edu.stanford.nlp.math
- Class edu.stanford.nlp.math.ArrayMath.InvalidElementException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1647150702529757545L
Package edu.stanford.nlp.objectbank
- Class edu.stanford.nlp.objectbank.LineIterator.LineIteratorFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - oper
```
Function<T1,T2> oper
```
- Class edu.stanford.nlp.objectbank.ObjectBank extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4030295596701541770L
  - Serialized Fields
    - rif
```
ReaderIteratorFactory rif
```
    - ifrf
```
IteratorFromReaderFactory<T> ifrf
```
    - contents
```
java.util.List<E> contents
```
    - keepInMemory
```
boolean keepInMemory
```
Package edu.stanford.nlp.optimization
- Class edu.stanford.nlp.optimization.QNMinimizer.SurpriseConvergence extends java.lang.Throwable implements Serializable
  
  serialVersionUID:
  
  4290178321643529559L
Package edu.stanford.nlp.parser.dvparser
- Class edu.stanford.nlp.parser.dvparser.DVModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException
```
      Throws:
      
      java.io.IOException
  - Serialized Fields
    - numBinaryMatrices
```
int numBinaryMatrices
```
    - numUnaryMatrices
```
int numUnaryMatrices
```
    - binaryTransformSize
```
int binaryTransformSize
```
    - unaryTransformSize
```
int unaryTransformSize
```
    - binaryScoreSize
```
int binaryScoreSize
```
    - unaryScoreSize
```
int unaryScoreSize
```
    - op
```
Options op
```
    - numCols
```
int numCols
```
    - numRows
```
int numRows
```
    - rand
```
java.util.Random rand
```
- Class edu.stanford.nlp.parser.dvparser.DVModelReranker extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7897546308624261207L
  - Serialized Fields
    - op
```
Options op
```
    - model
```
DVModel model
```
- Class edu.stanford.nlp.parser.dvparser.FilterConfusingRules extends java.lang.Object implements Serializable
  - Serialized Fields
    - unaryRules
```
java.util.Set<E> unaryRules
```
    - binaryRules
```
TwoDimensionalSet<K1,K2> binaryRules
```
Package edu.stanford.nlp.parser.lexparser
- Class edu.stanford.nlp.parser.lexparser.AbstractDependencyGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - tagProjection
```
TagProjection tagProjection
```
    - tagIndex
```
Index<E> tagIndex
```
    - wordIndex
```
Index<E> wordIndex
```
    - numTagBins
```
int numTagBins
```
    - tagBin
```
int[] tagBin
```
    - tlp
```
TreebankLanguagePack tlp
```
    - directional
```
boolean directional
```
    - useDistance
```
boolean useDistance
```
    - useCoarseDistance
```
boolean useCoarseDistance
```
    - lex
```
Lexicon lex
```
    - stopTW
```
IntTaggedWord stopTW
```
    - wildTW
```
IntTaggedWord wildTW
```
    - coarseDistanceBins
```
int[] coarseDistanceBins
```
    - regDistanceBins
```
int[] regDistanceBins
```
    - op
```
Options op
```
- Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4299501909017975915L
  - Serialized Fields
    - evalGF
```
boolean evalGF
```
      If true, then evaluation is over grammatical functions as well as the labels If false, then grammatical functions are stripped for evaluation. This really only makes sense if you've trained with grammatical functions but want to evaluate without them.
    - inputEncoding
```
java.lang.String inputEncoding
```
    - outputEncoding
```
java.lang.String outputEncoding
```
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams.AnnotatePunctuationFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - key
```
java.lang.String key
```
    - annotationMark
```
java.lang.String annotationMark
```
- Class edu.stanford.nlp.parser.lexparser.ArabicTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  8853426784197984653L
  - Serialized Fields
    - optionsString
```
java.lang.StringBuilder optionsString
```
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - retainPRD
```
boolean retainPRD
```
    - retainPPClr
```
boolean retainPPClr
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - collinizerRetainsPunctuation
```
boolean collinizerRetainsPunctuation
```
    - discardX
```
boolean discardX
```
    - headFinder
```
HeadFinder headFinder
```
    - annotationPatterns
```
java.util.Map<K,V> annotationPatterns
```
    - activeAnnotations
```
java.util.List<E> activeAnnotations
```
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - baselineFeatures
```
java.util.List<E> baselineFeatures
```
      These are the annotations included when the user selects the -arabicFactored option.
    - additionalFeatures
```
java.util.List<E> additionalFeatures
```
- Class edu.stanford.nlp.parser.lexparser.ArabicUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  4825624957364628771L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
- Class edu.stanford.nlp.parser.lexparser.BaseLexicon extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  40L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - uwModel
```
UnknownWordModel uwModel
```
    - uwModelTrainerClass
```
java.lang.String uwModelTrainerClass
```
    - trainOptions
```
TrainOptions trainOptions
```
    - testOptions
```
TestOptions testOptions
```
    - op
```
Options op
```
    - smoothInUnknownsThreshold
```
int smoothInUnknownsThreshold
```
      If a word has been seen more than this many times, then relative frequencies of tags are used for POS assignment; if not, they are smoothed with tag priors.
    - smartMutation
```
boolean smartMutation
```
      Have tags changeable based on statistics on word types having various taggings.
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - seenCounter
```
ClassicCounter<E> seenCounter
```
      Records the number of times word/tag pair was seen in training data. Includes word/tag pairs where one is a wildcard not a real word/tag.
    - smooth
```
double[] smooth
```
    - flexiTag
```
boolean flexiTag
```
    - useSignatureForKnownSmoothing
```
boolean useSignatureForKnownSmoothing
```
    - baseTagCounts
```
java.util.Map<K,V> baseTagCounts
```
      Only used when training, specifically when training on sentenes that weren't part of annotated (eg markovized, etc) data
    - tagsToBaseTags
```
int[] tagsToBaseTags
```
- Class edu.stanford.nlp.parser.lexparser.BaseUnknownWordModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6355171148751673822L
  - Serialized Fields
    - useFirst
```
boolean useFirst
```
    - useEnd
```
boolean useEnd
```
    - useGT
```
boolean useGT
```
    - useFirstCap
```
boolean useFirstCap
```
    - endLength
```
int endLength
```
    - unknownLevel
```
int unknownLevel
```
      What type of equivalence classing is done in getSignature
    - trainOptions
```
TrainOptions trainOptions
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - unSeenCounter
```
ClassicCounter<E> unSeenCounter
```
      Has counts for taggings in terms of unseen signatures. The IntTagWords are for (tag,sig), (tag,null), (null,sig), (null,null). (None for basic UNK if there are signatures.)
    - tagHash
```
java.util.Map<K,V> tagHash
```
      This maps from a tag (as a label) to a Counter from word signatures to their P(sig|tag), as estimated in the model. For Chinese, the word signature is just the first character or its unicode type for things that aren't Chinese characters.
    - seenEnd
```
java.util.Set<E> seenEnd
```
      This is the set of all signatures that we have seen.
    - unknownGT
```
java.util.Map<K,V> unknownGT
```
    - lex
```
Lexicon lex
```
      All classes that implement UnknownWordModel must call the constructor that initializes this variable.
- Class edu.stanford.nlp.parser.lexparser.BinaryGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - allRules
```
java.util.List<E> allRules
```
- Class edu.stanford.nlp.parser.lexparser.BinaryRule extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parent
```
int parent
```
    - score
```
float score
```
      Score should be a log probability
    - leftChild
```
int leftChild
```
    - rightChild
```
int rightChild
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.parser.lexparser.ChineseCharacterBasedLexicon extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5357655683145854069L
  - Serialized Fields
    - lengthPenalty
```
double lengthPenalty
```
    - penaltyType
```
int penaltyType
```
    - charDistributions
```
java.util.Map<K,V> charDistributions
```
    - knownChars
```
java.util.Set<E> knownChars
```
    - POSDistribution
```
Distribution<E> POSDistribution
```
    - useUnknownCharacterModel
```
boolean useUnknownCharacterModel
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
- Class edu.stanford.nlp.parser.lexparser.ChineseLexicon extends BaseLexicon implements Serializable
  
  serialVersionUID:
  
  -7836464391021114960L
  - Serialized Fields
    - useCharBasedUnknownWordModel
```
boolean useCharBasedUnknownWordModel
```
    - useGoodTuringUnknownWordModel
```
boolean useGoodTuringUnknownWordModel
```
    - probRandomWalk
```
edu.stanford.nlp.parser.lexparser.RandomWalk probRandomWalk
```
- Class edu.stanford.nlp.parser.lexparser.ChineseLexiconAndWordSegmenter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6554995189795187918L
  - Serialized Fields
    - chineseLexicon
```
ChineseLexicon chineseLexicon
```
    - wordSegmenter
```
WordSegmenter wordSegmenter
```
    - op
```
Options op
```
- Class edu.stanford.nlp.parser.lexparser.ChineseMarkovWordSegmenter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1559606198270645508L
  - Serialized Fields
    - initialPOSDist
```
Distribution<E> initialPOSDist
```
    - markovPOSDists
```
java.util.Map<K,V> markovPOSDists
```
    - lex
```
ChineseCharacterBasedLexicon lex
```
    - POSes
```
java.util.Set<E> POSes
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
- Class edu.stanford.nlp.parser.lexparser.ChineseSimWordAvgDepGrammar extends MLEDependencyGrammar implements Serializable
  
  serialVersionUID:
  
  -1845503582705055342L
  - Serialized Fields
    - simSmooth
```
double simSmooth
```
    - simArgMap
```
java.util.Map<K,V> simArgMap
```
    - simHeadMap
```
java.util.Map<K,V> simHeadMap
```
    - debug
```
boolean debug
```
    - verbose
```
boolean verbose
```
    - statsCounter
```
ClassicCounter<E> statsCounter
```
- Class edu.stanford.nlp.parser.lexparser.ChineseTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - ctlp
```
ChineseTreebankLanguagePack ctlp
```
      The variable ctlp stores the same thing as the tlp variable in AbstractTreebankParserParams, but pre-cast to be a ChineseTreebankLanguagePack.
    - charTags
```
boolean charTags
```
    - useCharacterBasedLexicon
```
boolean useCharacterBasedLexicon
```
    - useMaxentLexicon
```
boolean useMaxentLexicon
```
    - useMaxentDepGrammar
```
boolean useMaxentDepGrammar
```
    - segment
```
boolean segment
```
    - segmentMarkov
```
boolean segmentMarkov
```
    - sunJurafskyHeadFinder
```
boolean sunJurafskyHeadFinder
```
    - bikelHeadFinder
```
boolean bikelHeadFinder
```
    - discardFrags
```
boolean discardFrags
```
    - useSimilarWordMap
```
boolean useSimilarWordMap
```
    - segmenterClass
```
java.lang.String segmenterClass
```
    - lex
```
Lexicon lex
```
    - segmenter
```
WordSegmenter segmenter
```
    - headFinder
```
HeadFinder headFinder
```
    - chineseSplitDouHao
```
boolean chineseSplitDouHao
```
      Chinese: Split the dou hao (a punctuation mark separating members of a list) from other punctuation. Good but included below.
    - chineseSplitPunct
```
boolean chineseSplitPunct
```
      Chinese: split Chinese punctuation several ways, along the lines of English punctuation plus another category for the dou hao. Good.
    - chineseSplitPunctLR
```
boolean chineseSplitPunctLR
```
      Chinese: split left right/paren quote (if chineseSplitPunct is also true. Only very marginal gains, but seems positive.
    - markVVsisterIP
```
boolean markVVsisterIP
```
      Chinese: mark VVs that are sister of IP (communication & small-clause-taking verbs). Good: give 0.5%
    - markPsisterIP
```
boolean markPsisterIP
```
      Chinese: mark P's that are sister of IP. Negative effect
    - markIPsisterVVorP
```
boolean markIPsisterVVorP
```
      Chinese: mark IP's that are sister of VV or P. These rarely have punctuation. Small positive effect.
    - markADgrandchildOfIP
```
boolean markADgrandchildOfIP
```
      Chinese: mark ADs that are grandchild of IP.
    - gpaAD
```
boolean gpaAD
```
      Grandparent annotate all AD. Seems slightly negative.
    - chineseVerySelectiveTagPA
```
boolean chineseVerySelectiveTagPA
```
    - chineseSelectiveTagPA
```
boolean chineseSelectiveTagPA
```
    - markIPsisterBA
```
boolean markIPsisterBA
```
      Chinese: mark IPs that are sister of BA. These always have overt NP. Very slightly positive.
    - markVPadjunct
```
boolean markVPadjunct
```
      Chinese: mark phrases that are adjuncts of VP (these tend to be locatives/temporals, and have a specific distribution). Necessary even with chineseSplitVP==3 and parent annotation because parent annotation happens with unsplit parent categories. Slightly positive.
    - markNPmodNP
```
boolean markNPmodNP
```
      Chinese: mark NP modifiers of NPs. Quite positive (0.5%)
    - markModifiedNP
```
boolean markModifiedNP
```
      Chinese: mark left-modified NPs (rightmost NPs with a left-side mod). Slightly positive.
    - markNPconj
```
boolean markNPconj
```
      Chinese: mark NPs that are conjuncts. Negative on small set.
    - markMultiNtag
```
boolean markMultiNtag
```
      Chinese: mark nominal tags that are part of multi-nominal rewrites. Doesn't seem any good.
    - markIPsisDEC
```
boolean markIPsisDEC
```
      Chinese: mark IPs that are part of prenominal modifiers. Negative.
    - markIPconj
```
boolean markIPconj
```
      Chinese: mark IPs that are conjuncts. Or those that have (adjuncts or subjects)
    - markIPadjsubj
```
boolean markIPadjsubj
```
    - chineseSplitVP
```
int chineseSplitVP
```
      Chinese VP splitting. 0 = none; 1 = mark with -BA a VP that directly dominates a BA; 2 = mark with -BA a VP that directly dominates a BA or a VP that directly dominates a BA 3 = split VPs into VP-COMP, VP-CRD, VP-ADJ. (Negative value.)
    - mergeNNVV
```
boolean mergeNNVV
```
      Chinese: merge NN and VV. A lark.
    - unaryIP
```
boolean unaryIP
```
      Chinese: unary category marking
    - unaryCP
```
boolean unaryCP
```
    - paRootDtr
```
boolean paRootDtr
```
      Chinese: parent annotate daughter of root. Meant only for selectivesplit=false.
    - markPostverbalP
```
boolean markPostverbalP
```
      Chinese: mark P with a left aunt VV, and PP with a left sister VV. Note that it's necessary to mark both to thread the context-marking. Used to identify post-verbal P's, which are rare.
    - markPostverbalPP
```
boolean markPostverbalPP
```
    - splitBaseNP
```
boolean splitBaseNP
```
      Mark base NPs. Good.
    - tagWordSize
```
boolean tagWordSize
```
      Annotate tags for number of characters contained.
    - markCC
```
boolean markCC
```
      Mark phrases which are conjunctions. Appears negative, even with 200K words training data.
    - splitNPTMP
```
boolean splitNPTMP
```
      Whether to retain the -TMP functional tag on various phrasal categories. On 80K words training, minutely helpful; on 200K words, best option gives 0.6%. Doing splitNPTMP and splitPPTMP (but not splitXPTMP) is best.
    - splitPPTMP
```
boolean splitPPTMP
```
    - splitXPTMP
```
boolean splitXPTMP
```
    - dominatesV
```
boolean dominatesV
```
      Verbal distance -- mark whether symbol dominates a verb (V*). Seems bad for Chinese.
    - useGoodTuringUnknownWordModel
```
boolean useGoodTuringUnknownWordModel
```
    - useCharBasedUnknownWordModel
```
boolean useCharBasedUnknownWordModel
```
    - lengthPenalty
```
double lengthPenalty
```
      Parameters for a ChineseCharacterBasedLexicon
    - useUnknownCharacterModel
```
boolean useUnknownCharacterModel
```
    - penaltyType
```
int penaltyType
```
      penaltyType should be set as follows: 0: no length penalty 1: quadratic length penalty 2: penalty for continuation chars only TODO: make this an enum
    - depGramFeatureLevel
```
int depGramFeatureLevel
```
- Class edu.stanford.nlp.parser.lexparser.ChineseUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  221L
  - Serialized Fields
    - useUnicodeType
```
boolean useUnicodeType
```
    - seenFirst
```
java.util.Set<E> seenFirst
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  4153878351331522581L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - englishTrain
```
EnglishTreebankParserParams.EnglishTrain englishTrain
```
    - englishTest
```
EnglishTreebankParserParams.EnglishTest englishTest
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTest extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  183157656745674521L
  - Serialized Fields
    - retainNPTMPSubcategories
```
boolean retainNPTMPSubcategories
```
    - retainTMPSubcategories
```
boolean retainTMPSubcategories
```
    - retainADVSubcategories
```
boolean retainADVSubcategories
```
    - makeCopulaHead
```
boolean makeCopulaHead
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTrain extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1831576434872643L
  - Serialized Fields
    - leaveItAll
```
int leaveItAll
```
      if true, leave all PTB (functional tag) annotations (bad)
    - splitIN
```
int splitIN
```
      Annotate prepositions into subcategories. Values: 0 = no annotation 1 = IN with a ^S.* parent (putative subordinating conjunctions) marked differently from others (real prepositions). OK. 2 = Annotate IN prepositions 3 ways: ^S.* parent, ^N.* parent or rest (generally predicative ADJP, VP). Better than sIN=1. Good. 3 = Annotate prepositions 6 ways: real feature engineering. Great. 4 = Refinement of 3: allows -SC under SINV, WHADVP for -T and no -SCC if the parent is an NP. 5 = Like 4 but maps TO to IN in a "nominal" (N*, P*, A*) context. 6 = 4, but mark V/A complement and leave noun ones unmarked instead.
    - splitQuotes
```
boolean splitQuotes
```
      Mark quote marks for single vs. double so don't get mismatched ones.
    - splitSFP
```
boolean splitSFP
```
      Separate out sentence final punct. (. ! ?). Doesn't help.
    - splitPercent
```
boolean splitPercent
```
      Mark the nouns that are percent signs. Slightly good.
    - splitNPpercent
```
int splitNPpercent
```
      Mark phrases that are headed by %. A value of 0 = do nothing, 1 = only NP, 2 = NP and ADJP, 3 = NP, ADJP and QP, 4 = any phrase.
    - tagRBGPA
```
boolean tagRBGPA
```
      Grand parent annotate RB to try to distinguish sentential ones and ones in places like NP post modifier (things like 'very' are already distinguished as their parent is ADJP).
    - splitNNP
```
int splitNNP
```
      Mark NNP words as to position in phrase (single, left, right, inside) or subcategorizes NNP(S) as initials or initial/final in NP.
    - joinPound
```
boolean joinPound
```
      Join pound with dollar.
    - joinJJ
```
boolean joinJJ
```
      Joint comparative and superlative adjective with positive.
    - joinNounTags
```
boolean joinNounTags
```
      Join proper nouns with common nouns. This isn't to improve performance, but because Genia doesn't use proper noun tags in general.
    - splitPPJJ
```
boolean splitPPJJ
```
      A special test for "such" mainly ("such as Fred"). A wash, so omit
    - splitTRJJ
```
boolean splitTRJJ
```
      Put a special tag on 'transitive adjectives' with NP complement, like 'due May 15' -- it also catches 'such' in 'such as NP', which may be a good. Matches 658 times in 2-21 training corpus. Wash.
    - splitJJCOMP
```
boolean splitJJCOMP
```
      Put a special tag on 'adjectives with complements'. This acts as a general subcat feature for adjectives.
    - splitMoreLess
```
boolean splitMoreLess
```
      Specially mark the comparative/superlative words: less, least, more, most
    - unaryDT
```
boolean unaryDT
```
      Mark "Intransitive" DT. Good.
    - unaryRB
```
boolean unaryRB
```
      Mark "Intransitive" RB. Good.
    - unaryPRP
```
boolean unaryPRP
```
      "Intransitive" PRP. Wash -- basically a no-op really.
    - markReflexivePRP
```
boolean markReflexivePRP
```
      Mark reflexive PRP words.
    - unaryIN
```
boolean unaryIN
```
      Mark "Intransitive" IN. Minutely negative.
    - splitCC
```
int splitCC
```
      Provide annotation of conjunctions. Gives modest gains (numbers shown F1 increase with respect to goodPCFG in June 2005). A value of 1 annotates both "and" and "or" as "CC-C" (+0.29%), 2 annotates "but" and "&" separately (+0.17%), 3 annotates just "and" (equalsIgnoreCase) (+0.11%), 0 annotates nothing (+0.00%).
    - splitNOT
```
boolean splitNOT
```
      Annotates forms of "not" specially as tag "NOT". BAD
    - splitRB
```
boolean splitRB
```
      Split modifier (NP, AdjP) adverbs from others. This does nothing if you're already doing tagPA.
    - splitAux
```
int splitAux
```
      Make special tags for forms of BE and HAVE (and maybe DO/HELP, etc.). A value of 0 is do nothing. A value of 1 is the basic form. Positive PCFG effect, but neutral to negative in Factored, and impossible if you use gPA. A value of 2 adds in "s" = "'s" and delves further to disambiguate "'s" as BE or HAVE. Theoretically good, but no practical gains. A value of 3 adds DO. A value of 4 adds HELP (which also takes VB form complement) as DO. A value of 5 adds LET (which also takes VB form complement) as DO. A value of 6 adds MAKE (which also takes VB form complement) as DO. A value of 7 adds WATCH, SEE (which also take VB form complement) as DO. A value of 8 adds come, go, but not inflections (which colloquially can take a VB form complement) as DO. A value of 9 adds GET as BE. Differences are small. You get about 0.3 F1 by doing something; the best appear to be 2 or 3 for sentence exact and 7 or 8 for LP/LR F1.
    - vpSubCat
```
boolean vpSubCat
```
      Pitiful attempt at marking V* preterms with their surface subcat frames. Bad so far.
    - markDitransV
```
int markDitransV
```
      Attempt to record ditransitive verbs. The value 0 means do nothing; 1 records two or more NP or S* arguments, and 2 means to only record two or more NP arguments (that aren't NP-TMP). 1 gave neutral to bad results.
    - splitVP
```
int splitVP
```
      Add (head) tags to VPs. An argument of 0 = no head-subcategorization of VPs, 1 = add head tags (anything, as given by HeadFinder), 2 = add head tags, but collapse finite verb tags (VBP, VBD, VBZ, MD) together, 3 = only annotate verbal tags, and collapse finite verb tags (annotation is VBF, TO, VBG, VBN, VB, or zero), 4 = only split on categories of VBF, TO, VBG, VBN, VB, and map cases that are not headed by a verbal category to an appropriate category based on word suffix (ing, d, t, s, to) or to VB otherwise. We usually use a value of 3; 2 or 3 is much better than 0. See also splitVPNPAgr. If it is true, its effects override any value set for this parameter.
    - splitVPNPAgr
```
boolean splitVPNPAgr
```
      Put enough marking on VP and NP to permit "agreement".
    - splitSTag
```
int splitSTag
```
      Mark S/SINV/SQ nodes according to verbal tag. Meanings are: 0 = no subcategorization. 1 = mark with head tag 2 = mark only -VBF if VBZ/VBD/VBP/MD tag 3 = as 2 and mark -VBNF if TO/VBG/VBN/VB 4 = as 2 but only mark S not SINV/SQ 5 = as 3 but only mark S not SINV/SQ Previously seen as bad. Option 4 might be promising now.
    - markContainedVP
```
boolean markContainedVP
```
    - splitNPPRP
```
boolean splitNPPRP
```
    - dominatesV
```
int dominatesV
```
      Verbal distance -- mark whether symbol dominates a verb (V*, MD). Very good.
    - dominatesI
```
boolean dominatesI
```
      Verbal distance -- mark whether symbol dominates a preposition (IN)
    - dominatesC
```
boolean dominatesC
```
      Verbal distance -- mark whether symbol dominates a conjunction (CC)
    - markCC
```
int markCC
```
      Mark phrases which are conjunctions. 0 = No marking 1 = Any phrase with a CC daughter that isn't first or last. Possibly marginally positive. 2 = As 0 but also a non-marginal CONJP daughter. In principle good, but no gains. 3 = More like Charniak. Not yet implemented. Need to annotate _before_ annotate children! np or vp with two or more np/vp children, a comma, cc or conjp, and nothing else.
    - splitSGapped
```
int splitSGapped
```
      Mark specially S nodes with "gapped" subject (control, raising). 1 is basic version. 2 is better mark S nodes with "gapped" subject. 3 seems best on small training set, but all of these are too similar; 4 can't be differentiated. 5 is done on tree before empty splitting. (Bad!?)
    - splitNumNP
```
boolean splitNumNP
```
      Mark "numeric NPs". Probably bad?
    - splitPoss
```
int splitPoss
```
      Give a special tag to NPs which are possessive NPs (end in 's). A value of 0 means do nothing, 1 means tagging possessive NPs with "-P", 2 means restructure possessive NPs so that they introduce a POSSP node that takes as children the POS and a regularly structured NP. I.e., recover standard good linguistic practice circa 1985. This seems a good idea, but is almost a no-op (modulo fine points of markovization), since the previous NP-P phrase already uniquely captured what is now a POSSP.
    - splitBaseNP
```
int splitBaseNP
```
      Mark base NPs. A value of 0 = no marking, 1 = marking baseNP (ones which rewrite just as preterminals), and 2 = doing Collins-style marking, where an extra NP node is inserted above a baseNP, if it isn't already in an NP over NP construction, as in Collins 1999. This option shouldn't really be in EnglishTrain since it's needed at parsing time. But we don't currently use it.... A value of 1 is good.
    - splitTMP
```
int splitTMP
```
      Retain NP-TMP (or maybe PP-TMP) annotation. Good. The values for this parameter are defined in NPTmpRetainingTreeNormalizer.
    - splitSbar
```
int splitSbar
```
      Split SBAR nodes. 1 = mark 'in order to' purpose clauses; this is actually a small and inconsistent part of what is marked SBAR-PRP in the treebank, which is mainly 'because' reason clauses. 2 = mark all infinitive SBAR. 3 = do 1 and 2. A value of 1 seems minutely positive; 2 and 3 seem negative. Also get 'in case Sfin', 'In order to', and on one occasion 'in order that'
    - splitNPADV
```
int splitNPADV
```
      Retain NP-ADV annotation. 0 means strip "-ADV" annotation. 1 means to retain it, and to percolate it down to a head tag providing it can do it through a path of only NP nodes.
    - splitNPNNP
```
int splitNPNNP
```
      Mark NP-NNP. 0 is nothing; 1 is only NNP head, 2 is NNP and NNPS head; 3 is NNP or NNPS anywhere in local NP. All bad!
    - correctTags
```
boolean correctTags
```
      'Correct' tags to produce verbs in VPs, etc. where possible
    - rightPhrasal
```
boolean rightPhrasal
```
      Right edge has a phrasal node. Bad?
    - sisterSplitLevel
```
int sisterSplitLevel
```
      Set the support * KL cutoff level (1-4) for sister splitting -- don't use it, as far as we can tell so far
    - gpaRootVP
```
boolean gpaRootVP
```
      Grand-parent annotate (root mark) VP below ROOT. Seems negative.
    - makePPTOintoIN
```
int makePPTOintoIN
```
      Change TO inside PP to IN.
    - collapseWhCategories
```
int collapseWhCategories
```
      Collapse WHPP with PP, etc., in training and perhaps in evaluation. 1 = collapse phrasal categories. 2 = collapse POS categories. 4 = restore them in output (not yet implemented)
- Class edu.stanford.nlp.parser.lexparser.EnglishUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  4825624957364628770L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
    - wordClassesFile
```
java.lang.String wordClassesFile
```
- Class edu.stanford.nlp.parser.lexparser.FactoredLexicon extends BaseLexicon implements Serializable
  
  serialVersionUID:
  
  -744693222804176489L
  - Serialized Fields
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - morphIndex
```
Index<E> morphIndex
```
    - wordTag
```
TwoDimensionalIntCounter<K1,K2> wordTag
```
    - wordTagUnseen
```
Counter<E> wordTagUnseen
```
    - lemmaTag
```
TwoDimensionalIntCounter<K1,K2> lemmaTag
```
    - lemmaTagUnseen
```
Counter<E> lemmaTagUnseen
```
    - morphTag
```
TwoDimensionalIntCounter<K1,K2> morphTag
```
    - morphTagUnseen
```
Counter<E> morphTagUnseen
```
    - tagCounter
```
Counter<E> tagCounter
```
- Class edu.stanford.nlp.parser.lexparser.FrenchTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -6976724734594763986L
  - Serialized Fields
    - optionsString
```
java.lang.StringBuilder optionsString
```
    - headFinder
```
HeadFinder headFinder
```
    - annotationPatterns
```
java.util.Map<K,V> annotationPatterns
```
    - activeAnnotations
```
java.util.List<E> activeAnnotations
```
    - readPennFormat
```
boolean readPennFormat
```
    - collinizerRetainsPunctuation
```
boolean collinizerRetainsPunctuation
```
    - mwCounter
```
TwoDimensionalCounter<K1,K2> mwCounter
```
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - tagSpec
```
MorphoFeatureSpecification tagSpec
```
    - baselineFeatures
```
java.util.List<E> baselineFeatures
```
    - additionalFeatures
```
java.util.List<E> additionalFeatures
```
- Class edu.stanford.nlp.parser.lexparser.FrenchUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  -776564693549194424L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
- Class edu.stanford.nlp.parser.lexparser.GermanUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  221L
- Class edu.stanford.nlp.parser.lexparser.HebrewTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -3466519995341208619L
  - Serialized Fields
    - optionsString
```
java.lang.StringBuilder optionsString
```
- Class edu.stanford.nlp.parser.lexparser.IntDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - head
```
IntTaggedWord head
```
    - arg
```
IntTaggedWord arg
```
    - leftHeaded
```
boolean leftHeaded
```
    - distance
```
short distance
```
- Class edu.stanford.nlp.parser.lexparser.IntTaggedWord extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - word
```
int word
```
    - tag
```
short tag
```
- Class edu.stanford.nlp.parser.lexparser.Lattice extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5135076134500512556L
  - Serialized Fields
    - constraints
```
java.util.List<E> constraints
```
    - edges
```
java.util.List<E> edges
```
    - nodes
```
java.util.Set<E> nodes
```
    - edgeStartsAt
```
java.util.Map<K,V> edgeStartsAt
```
    - maxNode
```
int maxNode
```
- Class edu.stanford.nlp.parser.lexparser.LatticeEdge extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4416189959485854286L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - label
```
java.lang.String label
```
    - weight
```
double weight
```
    - start
```
int start
```
    - end
```
int end
```
    - attrs
```
java.util.Map<K,V> attrs
```
- Class edu.stanford.nlp.parser.lexparser.LexicalizedParser extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - lex
```
Lexicon lex
```
    - bg
```
BinaryGrammar bg
```
    - ug
```
UnaryGrammar ug
```
    - dg
```
DependencyGrammar dg
```
    - stateIndex
```
Index<E> stateIndex
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - op
```
Options op
```
    - reranker
```
Reranker reranker
```
- Class edu.stanford.nlp.parser.lexparser.MLEDependencyGrammar extends AbstractDependencyGrammar implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream stream)
                  throws java.io.IOException
```
      Throws:
      
      java.io.IOException
  - Serialized Fields
    - useSmoothTagProjection
```
boolean useSmoothTagProjection
```
    - useUnigramWordSmoothing
```
boolean useUnigramWordSmoothing
```
    - numWordTokens
```
int numWordTokens
```
    - argCounter
```
ClassicCounter<E> argCounter
```
      Stores all the counts for dependencies (with and without the word being a wildcard) in the reduced tag space.
    - stopCounter
```
ClassicCounter<E> stopCounter
```
    - smooth_aT_hTWd
```
double smooth_aT_hTWd
```
      Bayesian m-estimate prior for aT given hTWd against base distribution of aT given hTd. TODO: Note that these values are overwritten in the constructor. Find what is best and then maybe remove these defaults!
    - smooth_aTW_hTWd
```
double smooth_aTW_hTWd
```
      Bayesian m-estimate prior for aTW given hTWd against base distribution of aTW given hTd.
    - smooth_stop
```
double smooth_stop
```
    - interp
```
double interp
```
      Interpolation between model that directly predicts aTW and model that predicts aT and then aW given aT. This percent of the mass is on the model directly predicting aTW.
    - smooth_aTW_aT
```
double smooth_aTW_aT
```
    - smooth_aTW_hTd
```
double smooth_aTW_hTd
```
    - smooth_aT_hTd
```
double smooth_aT_hTd
```
    - smooth_aPTW_aPT
```
double smooth_aPTW_aPT
```
    - smoothTP
```
TagProjection smoothTP
```
    - smoothTPIndex
```
Index<E> smoothTPIndex
```
- Class edu.stanford.nlp.parser.lexparser.NegraPennTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  757812264219400466L
  - Serialized Fields
    - markRC
```
boolean markRC
```
    - markZuVP
```
boolean markZuVP
```
    - markLP
```
boolean markLP
```
    - markColon
```
boolean markColon
```
    - markKonjParent
```
boolean markKonjParent
```
    - markHDParent
```
boolean markHDParent
```
    - markContainsV
```
boolean markContainsV
```
    - nodeCleanup
```
int nodeCleanup
```
      Node cleanup is how node names are normalized. The known values are: 0 = do nothing; 1 = keep category and function; 2 = keep only category
    - headFinder
```
HeadFinder headFinder
```
    - treeNormalizerInsertNPinPP
```
boolean treeNormalizerInsertNPinPP
```
    - treeNormalizerLeaveGF
```
boolean treeNormalizerLeaveGF
```
    - treeReaderFactory
```
NegraPennTreeReaderFactory treeReaderFactory
```
- Class edu.stanford.nlp.parser.lexparser.NoSuchParseException extends java.util.NoSuchElementException implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.parser.lexparser.Options extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Making the TestOptions transient means it won't even be constructed when you deserialize an Options, so we need to construct it on our own when deserializing
      
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - lexOptions
```
Options.LexOptions lexOptions
```
    - tlpParams
```
TreebankLangParserParams tlpParams
```
      The treebank-specific parser parameters to use.
    - forceCNF
```
boolean forceCNF
```
      Forces parsing with strictly CNF grammar -- unary chains are converted to XP&YP symbols and back
    - doPCFG
```
boolean doPCFG
```
      Do a PCFG parse of the sentence. If both variables are on, also do a combined parse of the sentence.
    - doDep
```
boolean doDep
```
      Do a dependency parse of the sentence.
    - freeDependencies
```
boolean freeDependencies
```
      if true, any child can be the head (seems rather bad!)
    - directional
```
boolean directional
```
      Whether dependency grammar considers left/right direction. Good.
    - genStop
```
boolean genStop
```
    - useSmoothTagProjection
```
boolean useSmoothTagProjection
```
    - useUnigramWordSmoothing
```
boolean useUnigramWordSmoothing
```
    - distance
```
boolean distance
```
      Use distance bins in the dependency calculations
    - coarseDistance
```
boolean coarseDistance
```
      Use coarser distance (4 bins) in dependency calculations
    - dcTags
```
boolean dcTags
```
      "double count" tags rewrites as word in PCFG and Dep parser. Good for combined parsing only (it used to not kick in for PCFG parsing). This option is only used at Test time, but it is now in Options, so the correct choice for a grammar is recorded by a serialized parser. You should turn this off for a vanilla PCFG parser.
    - nodePrune
```
boolean nodePrune
```
      If true, inside the factored parser, remove any node from the final chosen tree which improves the PCFG score. This was added as the dependency factor tends to encourage 'deep' trees.
    - trainOptions
```
TrainOptions trainOptions
```
    - wordFunction
```
Function<T1,T2> wordFunction
```
      A function that maps words used in training and testing to new words. For example, it could be a function to lowercase text, such as edu.stanford.nlp.util.LowercaseFunction (which makes the parser case insensitive). This function is applied in LexicalizedParserQuery.parse and in the training methods which build a new parser.
    - rerankerKBest
```
int rerankerKBest
```
      If the parser has a reranker, it looks at this many trees when building the reranked list.
    - baseParserWeight
```
double baseParserWeight
```
      If reranking sentences, we can use the score from the original parser as well. This tells us how much weight to give that score.
- Class edu.stanford.nlp.parser.lexparser.Options.LexOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2805351374506855632L
  - Serialized Fields
    - useUnknownWordSignatures
```
int useUnknownWordSignatures
```
      Whether to use suffix and capitalization information for unknowns. Within the BaseLexicon model options have the following meaning: 0 means a single unknown token. 1 uses suffix, and capitalization. 2 uses a variant (richer) form of signature. Good. Use this one. Using the richer signatures in versions 3 or 4 seems to have very marginal or no positive value. 3 uses a richer form of signature that mimics the NER word type patterns. 4 is a variant of 2. 5 is another with more English specific morphology (good for English unknowns!). 6-9 are options for Arabic. 9 codes some patterns for numbers and derivational morphology, but also supports unknownPrefixSize and unknownSuffixSize. For German, 0 means a single unknown token, and non-zero means to use capitalization of first letter and a suffix of length unknownSuffixSize.
    - wordVectorFile
```
java.lang.String wordVectorFile
```
    - numHid
```
int numHid
```
      Number of hidden units in the word vectors. As setting of 0 will make it try to extract the size from the data file.
    - smoothInUnknownsThreshold
```
int smoothInUnknownsThreshold
```
      Words more common than this are tagged with MLE P(t|w). Default 100. The smoothing is sufficiently slight that changing this has little effect. But set this to 0 to be able to use the parser as a vanilla PCFG with no smoothing (not as a practical parser but for exposition or debugging).
    - smartMutation
```
boolean smartMutation
```
      Smarter smoothing for rare words.
    - useUnicodeType
```
boolean useUnicodeType
```
      Make use of unicode code point types in smoothing.
    - unknownSuffixSize
```
int unknownSuffixSize
```
      For certain Lexicons, a certain number of word-final letters are used to subclassify the unknown token. This gives the number of letters.
    - unknownPrefixSize
```
int unknownPrefixSize
```
      For certain Lexicons, a certain number of word-initial letters are used to subclassify the unknown token. This gives the number of letters.
    - uwModelTrainer
```
java.lang.String uwModelTrainer
```
      Model for unknown words that the lexicon should use. This is the name of a class.
    - flexiTag
```
boolean flexiTag
```
    - useSignatureForKnownSmoothing
```
boolean useSignatureForKnownSmoothing
```
      Whether to use signature rather than just being unknown as prior in known word smoothing. Currently only works if turned on for English.
    - wordClassesFile
```
java.lang.String wordClassesFile
```
      A file of word class data which may be used for smoothing, normally instead of hand-specified signatures.
- Class edu.stanford.nlp.parser.lexparser.ParserConstraint extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4955237758572202093L
  - Serialized Fields
    - start
```
int start
```
    - end
```
int end
```
    - state
```
java.util.regex.Pattern state
```
- Class edu.stanford.nlp.parser.lexparser.TestOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7256526346598L
  - Serialized Fields
    - noRecoveryTagging
```
boolean noRecoveryTagging
```
      If false, then failure of the PCFG parser to parse a sentence will trigger allowing all tags for words in parse recovery mode, with a log probability of -1000. If true, these extra taggings are not added. It is false by default. Use option -noRecoveryTagging to set to true.
    - doRecovery
```
boolean doRecovery
```
      If true, then failure of the PCFG factor to parse a sentence will trigger parse recovery mode.
    - useN5
```
boolean useN5
```
      If true, the n^4 "speed-up" is not used with the Factored Parser.
    - useFastFactored
```
boolean useFastFactored
```
      If true, use approximate factored algorithm, which just rescores PCFG k best, rather than exact factored algorithm. This algorithm requires the dependency grammar to exist for rescoring, but not for the dependency grammar to be run. Hence the correct usage for guarding code only required for exact A* factored parsing is now if (op.doPCFG && op.doDep && ! Test.useFastFactored).
    - iterativeCKY
```
boolean iterativeCKY
```
      If true, use faster iterative deepening CKY algorithm.
    - maxLength
```
int maxLength
```
      The maximum sentence length (including punctuation, etc.) to parse.
    - MAX_ITEMS
```
int MAX_ITEMS
```
      The maximum number of edges and hooks combined that the factored parser will build before giving up. This number should probably be relative to the sentence length parsed. In general, though, if the parser cannot parse a sentence after this much work then there is no good parse consistent between the PCFG and Dependency parsers. (Normally, depending on other flags), the parser will then just return the best PCFG parse.)
    - unseenSmooth
```
double unseenSmooth
```
      The amount of smoothing put in (as an m-estimate) for unknown words. If negative, set by the code in the lexicon class.
    - increasingLength
```
boolean increasingLength
```
      Parse trees in test treebank in order of increasing length.
    - preTag
```
boolean preTag
```
      Tag the sentences first, then parse given those (coarse) tags.
    - forceTags
```
boolean forceTags
```
      Parse using only tags given from correct answer or the POS tagger
    - forceTagBeginnings
```
boolean forceTagBeginnings
```
    - taggerSerializedFile
```
java.lang.String taggerSerializedFile
```
      POS tagger model used when preTag is enabled.
    - noFunctionalForcing
```
boolean noFunctionalForcing
```
      Only valid with force tags - strips away functionals when forcing the tags, meaning tags have to start appropriately but the parser will assign the functional part.
    - evalb
```
boolean evalb
```
      Write EvalB-readable output files.
    - verbose
```
boolean verbose
```
      Print a lot of extra output as you parse.
    - exhaustiveTest
```
boolean exhaustiveTest
```
    - pcfgThreshold
```
boolean pcfgThreshold
```
      If this variable is true, and the sum of the inside and outside score for a constituent is worse than the best known score for a sentence by more than pcfgThresholdValue, then -Inf is returned as the outside Score by oScore() (while otherwise the true outside score is returned).
    - pcfgThresholdValue
```
double pcfgThresholdValue
```
    - printAllBestParses
```
boolean printAllBestParses
```
      Print out all best PCFG parses.
    - depWeight
```
double depWeight
```
      Weighting on dependency log probs. The dependency grammar negative log probability scores are simply multiplied by this number.
    - prunePunc
```
boolean prunePunc
```
    - addMissingFinalPunctuation
```
boolean addMissingFinalPunctuation
```
      If a token list does not have sentence final punctuation near the end, then automatically add the default one. This might help parsing if the treebank is all punctuated. Not done if reading a treebank.
    - outputFormat
```
java.lang.String outputFormat
```
      Determines format of output trees: choose among penn, oneline
    - outputFormatOptions
```
java.lang.String outputFormatOptions
```
    - writeOutputFiles
```
boolean writeOutputFiles
```
      If true, write files parsed to a new file with the same name except for an added ".stp" extension.
    - outputFilesDirectory
```
java.lang.String outputFilesDirectory
```
      If the writeOutputFiles option is true, then output files appear in this directory. An unset value (null) means to use the directory of the source files. Use "" or . for the current directory.
    - outputFilesExtension
```
java.lang.String outputFilesExtension
```
      If the writeOutputFiles option is true, then output files appear with this extension. Use "" for no extension.
    - outputFilesPrefix
```
java.lang.String outputFilesPrefix
```
      If the writeOutputFiles option is true, then output files appear with this prefix.
    - outputkBestEquivocation
```
java.lang.String outputkBestEquivocation
```
      If this option is not null, output the k-best equivocation. Must be specified with printPCFGkBest.
    - maxSpanForTags
```
int maxSpanForTags
```
      The largest span to consider for word-hood. Used for parsing unsegmented Chinese text and parsing lattices. Keep it at 1 unless you know what you're doing.
    - lengthNormalization
```
boolean lengthNormalization
```
      Turns on normalizing scores for sentence length. Makes no difference (except decreased efficiency) unless maxSpanForTags is greater than one. Works only for PCFG (so far).
    - sample
```
boolean sample
```
      Used when you want to generate sample parses instead of finding the best parse. (NOT YET USED.)
    - printPCFGkBest
```
int printPCFGkBest
```
      Printing k-best parses from PCFG, when k > 0.
    - evalPCFGkBest
```
int evalPCFGkBest
```
      If using a kBest eval, use this many trees.
    - printFactoredKGood
```
int printFactoredKGood
```
      Printing k-best parses from PCFG, when k > 0.
    - evals
```
java.util.Properties evals
```
      What evaluations to report and how to report them (using LexicalizedParser). Known evaluations are: pcfgLB, pcfgCB, pcfgDA, pcfgTA, pcfgLL, pcfgRUO, pcfgCUO, pcfgCatE, pcfgChildSpecific, depDA, depTA, depLL, factLB, factCB, factDA, factTA, factLL, factChildSpecific. The default is pcfgLB,depDA,factLB,factTA. You need to negate those ones out (e.g., -evals "depDA=false") if you don't want them. LB = ParseEval labeled bracketing,
      CB = crossing brackets and zero crossing bracket rate,
      DA = dependency accuracy, TA = tagging accuracy,
      LL = log likelihood score,
      RUO/CUO = rules/categories under and over proposed,
      CatE = evaluation by phrasal category.
      ChildSpecific: supply an argument with =. F1 will be returned for only the nodes which have at least one child that matches this regular expression.
      Known styles are: runningAverages, summary, tsv.
      The default style is summary. You need to negate it out if you don't want it. Invalid names in the argument to this option are not reported!
    - fastFactoredCandidateMultiplier
```
int fastFactoredCandidateMultiplier
```
      This variable says to find k good fast factored parses, how many times k of the best PCFG parses should be examined.
    - fastFactoredCandidateAddend
```
int fastFactoredCandidateAddend
```
      This variable says to find k good factored parses, how many added on best PCFG parses should be examined.
    - useLexiconToScoreDependencyPwGt
```
boolean useLexiconToScoreDependencyPwGt
```
      If this is true, the Lexicon is used to score P(w|t) in the backoff inside the dependency grammar. (Otherwise, a MLE is used is w is seen, and a constant if w is unseen.
    - useNonProjectiveDependencyParser
```
boolean useNonProjectiveDependencyParser
```
      If this is true, perform non-projective dependency parsing.
    - testingThreads
```
int testingThreads
```
      Number of threads to use at test time. For example, -testTreebank can use this to go X times faster, with the negative consequence that output is not quite as nicely ordered.
- Class edu.stanford.nlp.parser.lexparser.TrainOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  72571349843538L
  - Serialized Fields
    - trainTreeFile
```
java.lang.String trainTreeFile
```
    - trainLengthLimit
```
int trainLengthLimit
```
    - cheatPCFG
```
boolean cheatPCFG
```
      Add all test set trees to training data for PCFG. (Currently only supported in FactoredParser main.)
    - markovFactor
```
boolean markovFactor
```
      Whether to do "horizontal Markovization" (as in ACL 2003 paper). False means regular PCFG expansions.
    - markovOrder
```
int markovOrder
```
    - hSelSplit
```
boolean hSelSplit
```
    - HSEL_CUT
```
int HSEL_CUT
```
    - markFinalStates
```
boolean markFinalStates
```
      Whether or not to mark final states in binarized grammar. This must be off to get most value out of grammar compaction.
    - openClassTypesThreshold
```
int openClassTypesThreshold
```
      A POS tag has to have been attributed to more than this number of word types before it is regarded as an open-class tag. Unknown words will only possibly be tagged as open-class tags (unless flexiTag is on). If flexiTag is on, unknown words will be able to be tagged any POS for which the unseenMap has nonzero count (that is, the tag was seen for a new word after unseen signature counting was started).
    - fractionBeforeUnseenCounting
```
double fractionBeforeUnseenCounting
```
      Start to aggregate signature-tag pairs only for words unseen in the first this fraction of the data.
    - PA
```
boolean PA
```
      This variable controls doing parent annotation of phrasal nodes. Good.
    - gPA
```
boolean gPA
```
      This variable controls doing 2 levels of parent annotation. Bad.
    - postPA
```
boolean postPA
```
    - postGPA
```
boolean postGPA
```
    - selectiveSplit
```
boolean selectiveSplit
```
      Only split the "common high KL divergence" parent categories.... Good.
    - selectiveSplitCutOff
```
double selectiveSplitCutOff
```
    - selectivePostSplit
```
boolean selectivePostSplit
```
    - selectivePostSplitCutOff
```
double selectivePostSplitCutOff
```
    - postSplitWithBaseCategory
```
boolean postSplitWithBaseCategory
```
      Whether, in post-splitting of categories, nodes are annotated with the (grand)parent's base category or with its complete subcategorized category.
    - sisterAnnotate
```
boolean sisterAnnotate
```
      Selective Sister annotation.
    - sisterSplitters
```
java.util.Set<E> sisterSplitters
```
    - markUnary
```
int markUnary
```
      Mark all unary nodes specially. Good for just PCFG. Bad for factored. markUnary affects phrasal nodes. A value of 0 means to do nothing; a value of 1 means to mark the parent (higher) node of a unary rewrite. A value of 2 means to mark the child (lower) node of a unary rewrie. Values of 1 and 2 only apply if the child (lower) node is phrasal. (A value of 1 is better than 2 in combos.) A value of 1 corresponds to the old boolean -unary flag.
    - markUnaryTags
```
boolean markUnaryTags
```
      Mark POS tags which are the sole member of their phrasal constituent. This is like markUnary=2, applied to POS tags.
    - splitPrePreT
```
boolean splitPrePreT
```
      Mark all pre-preterminals (also does splitBaseNP: don't need both)
    - tagPA
```
boolean tagPA
```
      Parent annotation on tags. Good (for PCFG?)
    - tagSelectiveSplit
```
boolean tagSelectiveSplit
```
      Do parent annotation on tags selectively. Neutral, but less splits.
    - tagSelectiveSplitCutOff
```
double tagSelectiveSplitCutOff
```
    - tagSelectivePostSplit
```
boolean tagSelectivePostSplit
```
    - tagSelectivePostSplitCutOff
```
double tagSelectivePostSplitCutOff
```
    - rightRec
```
boolean rightRec
```
      Right edge is right-recursive (X << X) Bad. (NP only is good)
    - leftRec
```
boolean leftRec
```
      Left edge is right-recursive (X << X) Bad.
    - collinsPunc
```
boolean collinsPunc
```
      Promote/delete punctuation like Collins. Bad (!)
    - splitters
```
java.util.Set<E> splitters
```
      Set the splitter strings. These are a set of parent and/or grandparent annotated categories which should be split off.
    - postSplitters
```
java.util.Set<E> postSplitters
```
    - deleteSplitters
```
java.util.Set<E> deleteSplitters
```
    - printTreeTransformations
```
int printTreeTransformations
```
      Just for debugging: check that your tree transforms work correctly. This will print the transformations of the first printTreeTransformations trees.
    - printAnnotatedPW
```
java.io.PrintWriter printAnnotatedPW
```
    - printBinarizedPW
```
java.io.PrintWriter printBinarizedPW
```
    - printStates
```
boolean printStates
```
    - compactGrammar
```
int compactGrammar
```
      How to compact grammars as FSMs. 0 = no compaction [uses makeSyntheticLabel1], 1 = no compaction but use label names that wrap from right to left in binarization [uses makeSyntheticLabel2], 2 = wrapping labels and materialize unary at top rewriting passive to active, 3 = ExactGrammarCompactor, 4 = LossyGrammarCompactor, 5 = CategoryMergingGrammarCompactor. (May 2007 CDM note: options 4 and 5 don't seem to be functioning sensibly. 0, 1, and 3 seem to be the 'good' options. 2 is only useful as input to 3. There seems to be no reason not to use 0, despite the default.)
    - leftToRight
```
boolean leftToRight
```
    - noTagSplit
```
boolean noTagSplit
```
    - ruleSmoothing
```
boolean ruleSmoothing
```
      Enables linear rule smoothing during grammar extraction but before grammar compaction. The alpha term is the same as that described in Petrov et al. (2006), and has range [0,1].
    - ruleSmoothingAlpha
```
double ruleSmoothingAlpha
```
    - smoothing
```
boolean smoothing
```
      TODO wsg2011: This is the old grammar smoothing parameter that no longer does anything in the parser. It should be removed.
    - ruleDiscount
```
double ruleDiscount
```
      Discounts the count of BinaryRule's (only, apparently) in training data.
    - printAnnotatedRuleCounts
```
boolean printAnnotatedRuleCounts
```
    - printAnnotatedStateCounts
```
boolean printAnnotatedStateCounts
```
    - basicCategoryTagsInDependencyGrammar
```
boolean basicCategoryTagsInDependencyGrammar
```
      Where to use the basic or split tags in the dependency grammar
    - preTransformer
```
TreeTransformer preTransformer
```
      A transformer to use on the training data before any other processing step. This is specified by using the -preTransformer flag when training the parser. A comma separated list of classes will be turned into a CompositeTransformer. This can be used to strip subcategories, to run a tsurgeon pattern, or any number of other useful operations.
    - taggedFiles
```
java.lang.String taggedFiles
```
      A set of files to use as extra information in the lexicon. This can provide tagged words which are not part of trees
    - predictSplits
```
boolean predictSplits
```
      Use the method reported by Berkeley for splitting and recombining states. This is an experimental and still in development reimplementation of that work.
    - splitCount
```
int splitCount
```
      If we are predicting splits, we loop this many times
    - splitRecombineRate
```
double splitRecombineRate
```
      If we are predicting splits, we recombine states at this rate every loop
    - simpleBinarizedLabels
```
boolean simpleBinarizedLabels
```
      When binarizing trees, don't annotate the labels with anything
    - noRebinarization
```
boolean noRebinarization
```
      When binarizing trees, don't binarize trees with two children. Only applies when using inside markov binarization for now.
    - trainingThreads
```
int trainingThreads
```
      If the training algorithm allows for parallelization, how many threads to use
    - dvKBest
```
int dvKBest
```
    - dvIterations
```
int dvIterations
```
    - dvBatchSize
```
int dvBatchSize
```
    - regCost
```
double regCost
```
    - qnIterationsPerBatch
```
int qnIterationsPerBatch
```
    - qnEstimates
```
int qnEstimates
```
      When training the DV parsing method, how many estimates to keep for the qn approximation.
    - qnTolerance
```
double qnTolerance
```
      When training the DV parsing method, the tolerance to use if we want to stop qn early
    - debugOutputSeconds
```
int debugOutputSeconds
```
      If larger than 0, the parser may choose to output debug information every X seconds
    - dvSeed
```
long dvSeed
```
    - learningRate
```
double learningRate
```
      How fast to learn (can mean different things for different algorithms)
    - deltaMargin
```
double deltaMargin
```
      How much to penalize the wrong trees for how different they are from the gold tree when training
    - unknownNumberVector
```
boolean unknownNumberVector
```
      Whether or not to build an unknown word vector specifically for numbers
    - unknownDashedWordVectors
```
boolean unknownDashedWordVectors
```
      Whether or not to handle unknown dashed words by taking the last part
    - unknownCapsVector
```
boolean unknownCapsVector
```
      Whether or not to build an unknown word vector for words with caps in them
    - dvSimplifiedModel
```
boolean dvSimplifiedModel
```
      Make the dv model as simple as possible
    - unknownChineseYearVector
```
boolean unknownChineseYearVector
```
      Whether or not to build an unknown word vector to match Chinese years
    - unknownChineseNumberVector
```
boolean unknownChineseNumberVector
```
      Whether or not to build an unknown word vector to match Chinese numbers
    - unknownChinesePercentVector
```
boolean unknownChinesePercentVector
```
      Whether or not to build an unknown word vector to match Chinese percentages
    - scalingForInit
```
double scalingForInit
```
      How much to scale certain parameters when initializing models. For example, the DVParser uses this to rescale its initial matrices.
    - maxTrainTimeSeconds
```
int maxTrainTimeSeconds
```
    - unkWord
```
java.lang.String unkWord
```
      Some models will use external data sources which contain information about unknown words. This variable is a way to provide the name of the unknown word in the external data source.
    - lowercaseWordVectors
```
boolean lowercaseWordVectors
```
      Whether or not to lowercase word vectors
    - transformMatrixType
```
TrainOptions.TransformMatrixType transformMatrixType
```
    - useContextWords
```
boolean useContextWords
```
- Class edu.stanford.nlp.parser.lexparser.TueBaDZParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  7303189408025355170L
  - Serialized Fields
    - hf
```
HeadFinder hf
```
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - markKonjParent
```
boolean markKonjParent
```
    - markContainsV
```
boolean markContainsV
```
    - markZu
```
boolean markZu
```
    - markColons
```
boolean markColons
```
    - leftPhrasal
```
boolean leftPhrasal
```
    - markHDParent
```
boolean markHDParent
```
    - leaveGF
```
boolean leaveGF
```
- Class edu.stanford.nlp.parser.lexparser.UnaryGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - coreRules
```
java.util.Map<K,V> coreRules
```
      The basic list of UnaryRules. Really this is treated as a set
- Class edu.stanford.nlp.parser.lexparser.UnaryRule extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parent
```
int parent
```
    - score
```
float score
```
      Score should be a log probability
    - child
```
int child
```

Package edu.stanford.nlp.parser.ui

Class edu.stanford.nlp.parser.ui.Parser extends javax.swing.JFrame implements Serializable

serialVersionUID:: 7179757799978939358L

Serialized Fields

parserPanel
```
ParserPanel parserPanel
```

untokEngItem

javax.swing.JCheckBoxMenuItem untokEngItem

tokChineseItem

javax.swing.JCheckBoxMenuItem tokChineseItem

untokChineseItem

javax.swing.JCheckBoxMenuItem untokChineseItem

jMenu2
```
javax.swing.JMenu jMenu2
```
loadParserItem
```
javax.swing.JMenuItem loadParserItem
```
loadDataItem
```
javax.swing.JMenuItem loadDataItem
```
jSeparator1
```
javax.swing.JSeparator jSeparator1
```
jMenu1
```
javax.swing.JMenu jMenu1
```
exitItem
```
javax.swing.JMenuItem exitItem
```
jMenuBar1
```
javax.swing.JMenuBar jMenuBar1
```

Class edu.stanford.nlp.parser.ui.ParserPanel extends javax.swing.JPanel implements Serializable

serialVersionUID:: -2118491857333662471L

Serialized Fields

encoding
```
java.lang.String encoding
```
segmentWords
```
boolean segmentWords
```
jfc
```
javax.swing.JFileChooser jfc
```

jfcLocation

edu.stanford.nlp.parser.ui.ParserPanel.JFileChooserLocation jfcLocation

chooseJarParser
```
JarFileChooser chooseJarParser
```
pageDialog
```
OpenPageDialog pageDialog
```

normalStyle

javax.swing.text.SimpleAttributeSet normalStyle

highlightStyle

javax.swing.text.SimpleAttributeSet highlightStyle

startIndex
```
int startIndex
```
endIndex
```
int endIndex
```
treePanel
```
TreeJPanel treePanel
```
parser
```
LexicalizedParser parser
```

lpThread

edu.stanford.nlp.parser.ui.ParserPanel.LoadParserThread lpThread

parseThread

edu.stanford.nlp.parser.ui.ParserPanel.ParseThread parseThread

timer
```
javax.swing.Timer timer
```
count
```
int count
```
glassPane
```
java.awt.Component glassPane
```
scrollWhenDone
```
boolean scrollWhenDone
```
Whether to scroll one sentence forward after parsing.
dataFileLabel
```
javax.swing.JLabel dataFileLabel
```
treeContainer
```
javax.swing.JPanel treeContainer
```
topPanel
```
javax.swing.JPanel topPanel
```
textScrollPane
```
javax.swing.JScrollPane textScrollPane
```
backButton
```
javax.swing.JButton backButton
```
statusLabel
```
javax.swing.JLabel statusLabel
```
loadFileButton
```
javax.swing.JButton loadFileButton
```
loadButtonPanel
```
javax.swing.JPanel loadButtonPanel
```
buttonsAndFilePanel
```
javax.swing.JPanel buttonsAndFilePanel
```
parseButton
```
javax.swing.JButton parseButton
```
parseNextButton
```
javax.swing.JButton parseNextButton
```
forwardButton
```
javax.swing.JButton forwardButton
```
parserFileLabel
```
javax.swing.JLabel parserFileLabel
```
clearButton
```
javax.swing.JButton clearButton
```
splitPane
```
javax.swing.JSplitPane splitPane
```
statusPanel
```
javax.swing.JPanel statusPanel
```
dataFilePanel
```
javax.swing.JPanel dataFilePanel
```
buttonPanel
```
javax.swing.JPanel buttonPanel
```
textPane
```
javax.swing.JTextPane textPane
```
progressBar
```
javax.swing.JProgressBar progressBar
```
parserFilePanel
```
javax.swing.JPanel parserFilePanel
```
loadParserButton
```
javax.swing.JButton loadParserButton
```
saveOutputButton
```
javax.swing.JButton saveOutputButton
```

Class edu.stanford.nlp.parser.ui.TreeJPanel extends javax.swing.JPanel implements Serializable
- Serialized Fields
  - VERTICAL_ALIGN
```
int VERTICAL_ALIGN
```
  - HORIZONTAL_ALIGN
```
int HORIZONTAL_ALIGN
```
  - maxFontSize
```
int maxFontSize
```
  - minFontSize
```
int minFontSize
```
  - tree
```
Tree tree
```

Package edu.stanford.nlp.process
- Class edu.stanford.nlp.process.CoreLabelTokenFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - addIndices
```
boolean addIndices
```
- Class edu.stanford.nlp.process.DistSimClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialized Fields
    - lexicon
```
java.util.Map<K,V> lexicon
```
    - cased
```
boolean cased
```
    - numberEquivalence
```
boolean numberEquivalence
```
    - unknownWordClass
```
java.lang.String unknownWordClass
```
Package edu.stanford.nlp.semgraph
- Class edu.stanford.nlp.semgraph.SemanticGraph extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - roots
```
java.util.Collection<E> roots
```
      The distinguished root vertices, if known.
    - graph
```
DirectedMultiGraph<V,E> graph
```
- Class edu.stanford.nlp.semgraph.SemanticGraphEdge extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - relation
```
GrammaticalRelation relation
```
    - weight
```
double weight
```
    - isExtra
```
boolean isExtra
```
    - source
```
IndexedWord source
```
    - target
```
IndexedWord target
```
Package edu.stanford.nlp.stats
- Class edu.stanford.nlp.stats.ClassicCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
double totalCount
```
    - defaultValue
```
double defaultValue
```
- Class edu.stanford.nlp.stats.Distribution extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6707148234288637809L
  - Serialized Fields
    - numberOfKeys
```
int numberOfKeys
```
    - reservedMass
```
double reservedMass
```
    - counter
```
Counter<E> counter
```
- Class edu.stanford.nlp.stats.GeneralizedCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - depth
```
int depth
```
    - total
```
double total
```
- Class edu.stanford.nlp.stats.IntCounter extends AbstractCounter<E> implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
int totalCount
```
    - defaultValue
```
int defaultValue
```
- Class edu.stanford.nlp.stats.TwoDimensionalCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - total
```
double total
```
    - outerMF
```
MapFactory<K,V> outerMF
```
    - innerMF
```
MapFactory<K,V> innerMF
```
    - defaultValue
```
double defaultValue
```
- Class edu.stanford.nlp.stats.TwoDimensionalIntCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - total
```
int total
```
    - outerMF
```
MapFactory<K,V> outerMF
```
    - innerMF
```
MapFactory<K,V> innerMF
```
    - defaultValue
```
int defaultValue
```
Package edu.stanford.nlp.tagger.maxent
- Class edu.stanford.nlp.tagger.maxent.TaggerConfig extends java.util.Properties implements Serializable
  
  serialVersionUID:
  
  -4136407850147157497L
Package edu.stanford.nlp.trees
- Class edu.stanford.nlp.trees.AbstractCollinsHeadFinder extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6540278059442931087L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - nonTerminalInfo
```
java.util.Map<K,V> nonTerminalInfo
```
    - defaultRule
```
java.lang.String[] defaultRule
```
      Default direction if no rule is found for category (the head/parent). Subclasses can turn it on if they like. If they don't it is an error if no rule is defined for a category (null is returned).
    - defaultLeftRule
```
java.lang.String[] defaultLeftRule
```
      These are built automatically from categoriesToAvoid and used in a fairly different fashion from defaultRule (above). These are used for categories that do have defined rules but where none of them have matched. Rather than picking the rightmost or leftmost child, we will use these to pick the the rightmost or leftmost child which isn't in categoriesToAvoid.
    - defaultRightRule
```
java.lang.String[] defaultRightRule
```
- Class edu.stanford.nlp.trees.AbstractTreebankLanguagePack extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6506749780512708352L
  - Serialized Fields
    - gfCharacter
```
char gfCharacter
```
      Default character for indicating that something is a grammatical fn; probably should be overridden by lang specific ones
    - punctTagStringAcceptFilter
```
Filter<T> punctTagStringAcceptFilter
```
    - punctWordStringAcceptFilter
```
Filter<T> punctWordStringAcceptFilter
```
    - sFPunctTagStringAcceptFilter
```
Filter<T> sFPunctTagStringAcceptFilter
```
    - eIPunctTagStringAcceptFilter
```
Filter<T> eIPunctTagStringAcceptFilter
```
    - startSymbolAcceptFilter
```
Filter<T> startSymbolAcceptFilter
```
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -1005188028979810143L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - emptyFilter
```
Filter<T> emptyFilter
```
    - aOverAFilter
```
Filter<T> aOverAFilter
```
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.AOverAFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.EmptyFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8914098359495987617L
- Class edu.stanford.nlp.trees.CollinsHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -8747319554557223437L
- Class edu.stanford.nlp.trees.Dependencies.DependentPuncTagRejectFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7732189363171164852L
  - Serialized Fields
    - tagRejectFilter
```
Filter<T> tagRejectFilter
```
- Class edu.stanford.nlp.trees.Dependencies.DependentPuncWordRejectFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1166489968248785287L
  - Serialized Fields
    - wordRejectFilter
```
Filter<T> wordRejectFilter
```
- Class edu.stanford.nlp.trees.EnglishGrammaticalStructure extends GrammaticalStructure implements Serializable
  
  serialVersionUID:
  
  -1866362375001969402L
- Class edu.stanford.nlp.trees.GrammaticalFunctionTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -2270472762938163327L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - root
```
java.lang.String root
```
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.trees.GrammaticalRelation extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  892618003417550128L
  - Serialized Fields
    - language
```
GrammaticalRelation.Language language
```
    - shortName
```
java.lang.String shortName
```
    - longName
```
java.lang.String longName
```
    - parent
```
GrammaticalRelation parent
```
    - children
```
java.util.List<E> children
```
    - sourcePattern
```
java.util.regex.Pattern sourcePattern
```
    - targetPatterns
```
java.util.List<E> targetPatterns
```
    - specific
```
java.lang.String specific
```
- Class edu.stanford.nlp.trees.GrammaticalStructure extends TreeGraph implements Serializable
  
  serialVersionUID:
  
  2286294455343892678L
  - Serialized Fields
    - dependencies
```
java.util.Set<E> dependencies
```
    - typedDependencies
```
java.util.List<E> typedDependencies
```
    - allTypedDependencies
```
java.util.List<E> allTypedDependencies
```
    - puncFilter
```
Filter<T> puncFilter
```
- Class edu.stanford.nlp.trees.LabeledScoredTreeNode extends Tree implements Serializable
  
  serialVersionUID:
  
  -8992385140984593817L
  - Serialized Fields
    - label
```
Label label
```
      Label of the parse tree.
    - score
```
double score
```
      Score of TreeNode
    - daughterTrees
```
Tree[] daughterTrees
```
      Daughters of the parse tree.
- Class edu.stanford.nlp.trees.LeftHeadFinder extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8453889846239508208L
- Class edu.stanford.nlp.trees.LengthTreeFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - length
```
int length
```
- Class edu.stanford.nlp.trees.ModCollinsHeadFinder extends CollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -5870387458902637256L
- Class edu.stanford.nlp.trees.NamedDependency extends UnnamedDependency implements Serializable
  
  serialVersionUID:
  
  -1635646451505721133L
  - Serialized Fields
    - name
```
java.lang.Object name
```
- Class edu.stanford.nlp.trees.NPTmpRetainingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  7548777133196579107L
  - Serialized Fields
    - temporalAnnotation
```
int temporalAnnotation
```
    - doSGappedStuff
```
boolean doSGappedStuff
```
    - leaveItAll
```
int leaveItAll
```
    - doAdverbialNP
```
boolean doAdverbialNP
```
    - headFinder
```
HeadFinder headFinder
```
- Class edu.stanford.nlp.trees.OrderedCombinationTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  326L
  - Serialized Fields
    - tns
```
java.util.List<E> tns
```
- Class edu.stanford.nlp.trees.PennTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
- Class edu.stanford.nlp.trees.SemanticHeadFinder extends ModCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  5721799188009249808L
  - Serialized Fields
    - verbalAuxiliaries
```
java.util.Set<E> verbalAuxiliaries
```
    - copulars
```
java.util.Set<E> copulars
```
    - passiveAuxiliaries
```
java.util.Set<E> passiveAuxiliaries
```
    - verbalTags
```
java.util.Set<E> verbalTags
```
    - unambiguousAuxiliaryTags
```
java.util.Set<E> unambiguousAuxiliaryTags
```
- Class edu.stanford.nlp.trees.SimpleTree extends Tree implements Serializable
  
  serialVersionUID:
  
  -8075763706877132926L
  - Serialized Fields
    - daughterTrees
```
Tree[] daughterTrees
```
      Daughters of the parse tree.
- Class edu.stanford.nlp.trees.Tree extends java.util.AbstractCollection<Tree> implements Serializable
  
  serialVersionUID:
  
  5441849457648722744L
- Class edu.stanford.nlp.trees.TreeFilters.HasMatchingChild extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - pattern
```
java.util.regex.Pattern pattern
```
- Class edu.stanford.nlp.trees.TreeGraph extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - root
```
TreeGraphNode root
```
      The root node of this treegraph.
    - indexMap
```
java.util.Map<K,V> indexMap
```
      A map from arbitrary integer indices to nodes.
- Class edu.stanford.nlp.trees.TreeGraphNode extends Tree implements Serializable
  
  serialVersionUID:
  
  5080098143617475328L
  - Serialized Fields
    - label
```
CoreLabel label
```
      Label for this node.
    - parent
```
TreeGraphNode parent
```
      Parent of this node.
    - children
```
TreeGraphNode[] children
```
      Children of this node.
    - tg
```
TreeGraph tg
```
      The TreeGraph of which this node is part.
- Class edu.stanford.nlp.trees.TreeNormalizer extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1540681875853883387L
- Class edu.stanford.nlp.trees.TypedDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7690294213151279779L
  - Serialized Fields
    - reln
```
GrammaticalRelation reln
```
    - gov
```
TreeGraphNode gov
```
    - dep
```
TreeGraphNode dep
```
    - extra
```
boolean extra
```
- Class edu.stanford.nlp.trees.UnnamedConcreteDependency extends UnnamedDependency implements Serializable
  
  serialVersionUID:
  
  -8836949694741145222L
  - Serialized Fields
    - headIndex
```
int headIndex
```
    - depIndex
```
int depIndex
```
- Class edu.stanford.nlp.trees.UnnamedDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -3768440215342256085L
  - Serialized Fields
    - regentText
```
java.lang.String regentText
```
    - dependentText
```
java.lang.String dependentText
```
    - regent
```
Label regent
```
    - dependent
```
Label dependent
```
Package edu.stanford.nlp.trees.international.arabic
- Class edu.stanford.nlp.trees.international.arabic.ArabicHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  6203368998430280740L
  - Serialized Fields
    - tagSet
```
ArabicHeadFinder.TagSet tagSet
```
    - predPattern
```
java.util.regex.Pattern predPattern
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
  - Serialized Fields
    - tf
```
TokenizerFactory<T> tf
```
      TODO: there is no way to change this using options.
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -1592231121068698494L
  - Serialized Fields
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - markPRDverb
```
boolean markPRDverb
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - retainPPClr
```
boolean retainPPClr
```
    - prdPattern
```
java.util.regex.Pattern prdPattern
```
    - prdVerbPattern
```
TregexPattern prdVerbPattern
```
    - npSbjPattern
```
TregexPattern npSbjPattern
```
    - rootLabel
```
java.lang.String rootLabel
```
    - lexMapper
```
Mapper lexMapper
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer.ArabicEmptyFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7417844982953945964L
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1973767605277873017L
  - Serialized Fields
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - retainPRD
```
boolean retainPRD
```
    - retainPPClr
```
boolean retainPPClr
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - filterX
```
boolean filterX
```
    - noNormalization
```
boolean noNormalization
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory.ArabicRawTreeReaderFactory extends ArabicTreeReaderFactory implements Serializable
  
  serialVersionUID:
  
  -5693371540982097793L
Package edu.stanford.nlp.trees.international.french
- Class edu.stanford.nlp.trees.international.french.DybroFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  8798606577201646967L
- Class edu.stanford.nlp.trees.international.french.FrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  8747319554557223422L
- Class edu.stanford.nlp.trees.international.french.FrenchTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  -7338244949063822519L
- Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  7868735300308066991L
  - Serialized Fields
    - rootLabel
```
java.lang.String rootLabel
```
- Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer.FrenchAOverAFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  793800623099852951L
- Class edu.stanford.nlp.trees.international.french.FrenchTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6928967570430642163L
  - Serialized Fields
    - readPennFormat
```
boolean readPennFormat
```
Package edu.stanford.nlp.trees.international.hebrew
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  4787589385598144401L
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -3129547164200725933L
  - Serialized Fields
    - hebrewEmptyFilter
```
Filter<T> hebrewEmptyFilter
```
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer.HebrewEmptyFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7256461296718287280L
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  818065349424602548L
Package edu.stanford.nlp.trees.international.negra
- Class edu.stanford.nlp.trees.international.negra.NegraHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7253035927065152766L
  - Serialized Fields
    - coordSwitch
```
boolean coordSwitch
```
    - left
```
java.lang.String left
```
    - right
```
java.lang.String right
```
- Class edu.stanford.nlp.trees.international.negra.NegraLabel extends StringLabel implements Serializable
  
  serialVersionUID:
  
  2847331882765391095L
  - Serialized Fields
    - edge
```
java.lang.String edge
```
    - features
```
java.util.Map<K,V> features
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
  - Serialized Fields
    - leaveGF
```
boolean leaveGF
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  8529514903815041064L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category
    - tlp
```
TreebankLanguagePack tlp
```
    - insertNPinPP
```
boolean insertNPinPP
```
    - emptyFilter
```
Filter<T> emptyFilter
```
    - aOverAFilter
```
Filter<T> aOverAFilter
```
    - prepositionTags
```
java.util.Set<E> prepositionTags
```
    - postpositionTags
```
java.util.Set<E> postpositionTags
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5731352106152470304L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
    - tlp
```
TreebankLanguagePack tlp
```
    - treeNormalizerInsertNPinPP
```
boolean treeNormalizerInsertNPinPP
```
Package edu.stanford.nlp.trees.international.pennchinese
- Class edu.stanford.nlp.trees.international.pennchinese.BikelChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -5445795668059315082L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseEnglishWordMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7655332268578049993L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - normalized
```
boolean normalized
```
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseGrammaticalStructure extends GrammaticalStructure implements Serializable
  
  serialVersionUID:
  
  8877651855167458256L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  6143632784691159283L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseSemanticHeadFinder extends ChineseHeadFinder implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  5757403475523638802L
  - Serialized Fields
    - tf
```
TokenizerFactory<T> tf
```
- Class edu.stanford.nlp.trees.international.pennchinese.CTBErrorCorrectingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -8203853817025401845L
  - Serialized Fields
    - tagExtender
```
TreeTransformer tagExtender
```
    - splitNPTMP
```
boolean splitNPTMP
```
    - splitPPTMP
```
boolean splitPPTMP
```
    - splitXPTMP
```
boolean splitXPTMP
```
    - chineseEmptyFilter
```
Filter<T> chineseEmptyFilter
```
- Class edu.stanford.nlp.trees.international.pennchinese.SunJurafskyChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7942375587642755210L
Package edu.stanford.nlp.trees.international.tuebadz
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - left
```
java.lang.String left
```
    - right
```
java.lang.String right
```
    - coordSwitch
```
boolean coordSwitch
```
    - headMarkedPattern
```
java.util.regex.Pattern headMarkedPattern
```
    - headMarkedPattern2
```
java.util.regex.Pattern headMarkedPattern2
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  2697418320262700673L
  - Serialized Fields
    - limitedGF
```
boolean limitedGF
```
    - leaveGF
```
boolean leaveGF
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZPennTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  8009544230321390490L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - root
```
java.lang.String root
```
    - tlp
```
TreebankLanguagePack tlp
```
    - tns
```
java.util.List<E> tns
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1614799885744961795L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - nodeCleanup
```
int nodeCleanup
```
Package edu.stanford.nlp.trees.tregex
- Class edu.stanford.nlp.trees.tregex.ParseException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.trees.tregex.Token currentToken
```
      This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
    - eol
```
java.lang.String eol
```
      The end of line string for this machine.
- Class edu.stanford.nlp.trees.tregex.TregexParseException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.trees.tregex.TregexPattern extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5060298043763944913L
  - Serialized Fields
    - neg
```
boolean neg
```
    - opt
```
boolean opt
```
    - patternString
```
java.lang.String patternString
```
Package edu.stanford.nlp.trees.tregex.tsurgeon
- Class edu.stanford.nlp.trees.tregex.tsurgeon.ParseException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.trees.tregex.tsurgeon.Token currentToken
```
      This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
    - eol
```
java.lang.String eol
```
      The end of line string for this machine.
- Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonParseException extends java.lang.RuntimeException implements Serializable
Package edu.stanford.nlp.util
- Class edu.stanford.nlp.util.ArrayCoreMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException
```
      Overridden serialization method: compacts our map before writing.
      
      Throws:
      
      java.io.IOException - If IO error
  - Serialized Fields
    - keys
```
java.lang.Class<T>[] keys
```
      Array of keys
    - values
```
java.lang.Object[] values
```
      Array of values
    - size
```
int size
```
      Total number of elements actually in keys,values
- Class edu.stanford.nlp.util.ArrayMap extends java.util.AbstractMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - entryArray
```
edu.stanford.nlp.util.ArrayMap.Entry<K,V>[] entryArray
```
    - capacity
```
int capacity
```
    - size
```
int size
```
    - hashCodeCache
```
int hashCodeCache
```
- Class edu.stanford.nlp.util.ArrayStringFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - words
```
java.lang.String[] words
```
    - length
```
int length
```
- Class edu.stanford.nlp.util.CollectionFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3711321773145894069L
- Class edu.stanford.nlp.util.CollectionFactory.ArrayListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.CollectionFactory.HashSetFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -6268401669449458602L
- Class edu.stanford.nlp.util.CollectionFactory.LinkedListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -4236184979948498000L
- Class edu.stanford.nlp.util.CollectionFactory.SizedArrayListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - defaultSize
```
int defaultSize
```
- Class edu.stanford.nlp.util.CollectionFactory.TreeSetFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -3451920268219478134L
- Class edu.stanford.nlp.util.CollectionValuedMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -9064664153962599076L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - cf
```
CollectionFactory<T> cf
```
    - treatCollectionsAsImmutable
```
boolean treatCollectionsAsImmutable
```
    - mf
```
MapFactory<K,V> mf
```
    - emptyValue
```
java.util.Collection<E> emptyValue
```
      The empty collection to be returned when a get doesn't find the key. The collection returned should be empty, such as Collections.emptySet, for example.
- Class edu.stanford.nlp.util.DeltaCollectionValuedMap extends CollectionValuedMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - originalMap
```
CollectionValuedMap<K,V> originalMap
```
    - deltaMap
```
java.util.Map<K,V> deltaMap
```
- Class edu.stanford.nlp.util.DeltaIndex extends java.util.AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  -1459230891686013411L
  - Serialized Fields
    - backingIndex
```
Index<E> backingIndex
```
    - spilloverIndex
```
Index<E> spilloverIndex
```
    - backingIndexSize
```
int backingIndexSize
```
    - locked
```
boolean locked
```
- Class edu.stanford.nlp.util.Filters.ConjFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
java.util.List<E> filters
```
- Class edu.stanford.nlp.util.Filters.DisjFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
java.util.List<E> filters
```
- Class edu.stanford.nlp.util.Filters.RandomFilter extends java.lang.Object implements Serializable
  - Serialized Fields
    - random
```
java.util.Random random
```
    - fraction
```
double fraction
```
- Class edu.stanford.nlp.util.FixedPrioritiesPriorityQueue extends java.util.AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - size
```
int size
```
    - capacity
```
int capacity
```
    - elements
```
java.util.List<E> elements
```
    - priorities
```
double[] priorities
```
- Class edu.stanford.nlp.util.HashableCoreMap extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - immutableKeys
```
java.util.Set<E> immutableKeys
```
      Set of immutable keys
    - hashcode
```
int hashcode
```
      Pre-computed hashcode
- Class edu.stanford.nlp.util.HashableCoreMap.HashableCoreMapException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.HashIndex extends java.util.AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  5398562825928375260L
  - Serialized Fields
    - objects
```
java.util.ArrayList<E> objects
```
    - indexes
```
java.util.Map<K,V> indexes
```
    - locked
```
boolean locked
```
    - semaphore
```
java.util.concurrent.Semaphore semaphore
```
- Class edu.stanford.nlp.util.IdentityHashSet extends java.util.AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  -5024744406713321676L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Deserialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException
```
      Serialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      java.io.IOException
- Class edu.stanford.nlp.util.Interval extends Pair<E extends java.lang.Comparable<E>,E extends java.lang.Comparable<E>> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - flags
```
int flags
```
- Class edu.stanford.nlp.util.IntPair extends IntTuple implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.IntQuadruple extends IntTuple implements Serializable
  
  serialVersionUID:
  
  7154973101012473479L
- Class edu.stanford.nlp.util.IntTriple extends IntTuple implements Serializable
  
  serialVersionUID:
  
  -3744404627253652799L
- Class edu.stanford.nlp.util.IntTuple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7266305463893511982L
  - Serialized Fields
    - elements
```
int[] elements
```
- Class edu.stanford.nlp.util.IntUni extends IntTuple implements Serializable
  
  serialVersionUID:
  
  -7182556672628741200L
- Class edu.stanford.nlp.util.LowercaseFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.MapFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4529666940763477360L
- Class edu.stanford.nlp.util.MetaClass.ClassCreationException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -5980065992461870357L
- Class edu.stanford.nlp.util.MetaClass.ConstructorNotFoundException extends MetaClass.ClassCreationException implements Serializable
  
  serialVersionUID:
  
  -5980065992461870357L
- Class edu.stanford.nlp.util.MutableDouble extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - d
```
double d
```
- Class edu.stanford.nlp.util.MutableInteger extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - i
```
int i
```
- Class edu.stanford.nlp.util.Pair extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1360822168806852921L
  - Serialized Fields
    - first
```
java.lang.Object first
```
      Direct access is deprecated. Use first().
    - second
```
java.lang.Object second
```
      Direct access is deprecated. Use second().
- Class edu.stanford.nlp.util.ReflectionLoading.ReflectionLoadingException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -3324911744277952585L
- Class edu.stanford.nlp.util.RuntimeInterruptedException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.util.ScoredComparator extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - ascending
```
boolean ascending
```
- Class edu.stanford.nlp.util.StringParsingTask.ParserException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.ThreeDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.Triple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4182871682751645440L
  - Serialized Fields
    - first
```
java.lang.Object first
```
    - second
```
java.lang.Object second
```
    - third
```
java.lang.Object third
```
- Class edu.stanford.nlp.util.TwoDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - mf1
```
MapFactory<K,V> mf1
```
    - mf2
```
MapFactory<K,V> mf2
```
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.TwoDimensionalSet extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - backingMap
```
TwoDimensionalMap<K1,K2,V> backingMap
```
- Class edu.stanford.nlp.util.UTF8EquivalenceFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L

Serialized Form

Package edu.stanford.nlp.graph

Class edu.stanford.nlp.graph.DirectedMultiGraph extends java.lang.Object implements Serializable

Serialized Fields

outgoingEdges

incomingEdges

Package edu.stanford.nlp.international.arabic

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification.ArabicMorphoFeatures extends MorphoFeatures implements Serializable

Class edu.stanford.nlp.international.arabic.Buckwalter extends java.lang.Object implements Serializable

Serialized Fields

outputUnicodeValues

arabicChars

buckChars

unicode2Buckwalter

u2bMap

b2uMap

unmappable

Package edu.stanford.nlp.international.arabic.pipeline

Class edu.stanford.nlp.international.arabic.pipeline.DefaultLexicalMapper extends java.lang.Object implements Serializable

Serialized Fields

utf8ArabicChart

bwAlefChar

bwDiacritics

bwTatweel

bwAlef

bwQuran

bwNullAnaphoraMarker

latinPunc

arabicPunc

arabicDigit

utf8Diacritics

utf8Tatweel

utf8Alef

utf8Quran

utf8ProDrop

segmentationMarker

morphemeBoundary

hasDigit

useATBVocalizedSectionMapping

stripMorphemeMarkersInUTF8

stripSegmentationMarkersInUTF8

parentTagString

parentTagsToEscape

utf8CliticString

bwClitics

Package edu.stanford.nlp.international.arabic.process

Class edu.stanford.nlp.international.arabic.process.ArabicTokenizer.ArabicTokenizerFactory extends java.lang.Object implements Serializable

Serialized Fields

factory

lexerProperties

Package edu.stanford.nlp.international.french

Class edu.stanford.nlp.international.french.FrenchMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

Package edu.stanford.nlp.international.french.process

Class edu.stanford.nlp.international.french.process.FrenchTokenizer.FrenchTokenizerFactory extends java.lang.Object implements Serializable

Serialized Fields

factory

lexerProperties

Package edu.stanford.nlp.international.morph

Class edu.stanford.nlp.international.morph.MorphoFeatures extends java.lang.Object implements Serializable

Serialized Fields

fSpec

altTag

Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends java.lang.Object implements Serializable

Serialized Fields

activeFeatures

Package edu.stanford.nlp.io

Class edu.stanford.nlp.io.RuntimeIOException extends java.lang.RuntimeException implements Serializable

Package edu.stanford.nlp.io.ui

Class edu.stanford.nlp.io.ui.OpenPageDialog extends javax.swing.JDialog implements Serializable

Serialized Fields

jfc

status

urlTextField

openButton

jLabel1

jPanel3

jLabel2

jPanel2

cancelButton