docs: public void setProperties(Properties props, boolean printProps) {
      this.props = props;
      StringBuilder sb = new StringBuilder(stringRep);
      for (Enumeration e = props.propertyNames(); e.hasMoreElements();) {
        String key = (String) e.nextElement();
        String val = props.getProperty(key);
        if (!(key.length() == 0 && val.length() == 0)) {
          if (printProps) {
            System.err.println(key + '=' + val);
          }
          sb.append(key).append('=').append(val).append('\n');
        }
        if (key.equalsIgnoreCase("macro")) {
          if (Boolean.parseBoolean(val)) {
            useObservedSequencesOnly = true;
            readerAndWriter = "edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter";
            // useClassFeature = true;
            // submit
            useLongSequences = true;
            useTaggySequences = true;
            useNGrams = true;
            usePrev = true;
            useNext = true;
            useTags = true;
            useWordPairs = true;
            useSequences = true;
            usePrevSequences = true;
            // noMidNGrams
            noMidNGrams = true;
            // reverse
            useReverse = true;
            // typeseqs3
            useTypeSeqs = true;
            useTypeSeqs2 = true;
            useTypeySequences = true;
            // wordtypes2 && known
            wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
            // occurrence
            useOccurrencePatterns = true;
            // realword
            useLastRealWord = true;
            useNextRealWord = true;
            // smooth
            sigma = 3.0;
            // normalize
            normalize = true;
            normalizeTimex = true;
          }
        } else if (key.equalsIgnoreCase("goodCoNLL")) {
          if (Boolean.parseBoolean(val)) {
            // featureFactory = "edu.stanford.nlp.ie.NERFeatureFactory";
            readerAndWriter = "edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter";
            useObservedSequencesOnly = true;
            // useClassFeature = true;
            useLongSequences = true;
            useTaggySequences = true;
            useNGrams = true;
            usePrev = true;
            useNext = true;
            useTags = true;
            useWordPairs = true;
            useSequences = true;
            usePrevSequences = true;
            // noMidNGrams
            noMidNGrams = true;
            // should this be set?? maxNGramLeng = 6; No (to get best score).
            // reverse
            useReverse = false;
            // typeseqs3
            useTypeSeqs = true;
            useTypeSeqs2 = true;
            useTypeySequences = true;
            // wordtypes2 && known
            wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
            // occurrence
            useOccurrencePatterns = true;
            // realword
            useLastRealWord = true;
            useNextRealWord = true;
            // smooth
            sigma = 50.0; // increased Aug 2006 from 20; helpful with less feats
            // normalize
            normalize = true;
            normalizeTimex = true;
            maxLeft = 2;
            useDisjunctive = true;
            disjunctionWidth = 4; // clearly optimal for CoNLL
            useBoundarySequences = true;
            useLemmas = true; // no-op except for German
            usePrevNextLemmas = true; // no-op except for German
            inputEncoding = "iso-8859-1"; // needed for CoNLL German files
            // opt
            useQN = true;
            QNsize = 15;
          }
        } else if (key.equalsIgnoreCase("conllNoTags")) {
          if (Boolean.parseBoolean(val)) {
            readerAndWriter = "edu.stanford.nlp.sequences.ColumnDocumentReaderAndWriter";
            // trainMap=testMap="word=0,answer=1";
            map = "word=0,answer=1";
            useObservedSequencesOnly = true;
            // useClassFeature = true;
            useLongSequences = true;
            // useTaggySequences = true;
            useNGrams = true;
            usePrev = true;
            useNext = true;
            // useTags = true;
            useWordPairs = true;
            useSequences = true;
            usePrevSequences = true;
            // noMidNGrams
            noMidNGrams = true;
            // reverse
            useReverse = false;
            // typeseqs3
            useTypeSeqs = true;
            useTypeSeqs2 = true;
            useTypeySequences = true;
            // wordtypes2 && known
            wordShape = WordShapeClassifier.WORDSHAPEDAN2USELC;
            // occurrence
            // useOccurrencePatterns = true;
            // realword
            useLastRealWord = true;
            useNextRealWord = true;
            // smooth
            sigma = 20.0;
            adaptSigma = 20.0;
            // normalize
            normalize = true;
            normalizeTimex = true;
            maxLeft = 2;
            useDisjunctive = true;
            disjunctionWidth = 4;
            useBoundarySequences = true;
            // useLemmas = true; // no-op except for German
            // usePrevNextLemmas = true; // no-op except for German
            inputEncoding = "iso-8859-1";
            // opt
            useQN = true;
            QNsize = 15;
          }
        } else if (key.equalsIgnoreCase("notags")) {
          if (Boolean.parseBoolean(val)) {
            // turn off all features that use POS tags
            // this is slightly crude: it also turns off a few things that
            // don't use tags in e.g., useTaggySequences
            useTags = false;
            useSymTags = false;
            useTaggySequences = false;
            useOccurrencePatterns = false;
          }
        } else if (key.equalsIgnoreCase("submit")) {
          if (Boolean.parseBoolean(val)) {
            useLongSequences = true;
            useTaggySequences = true;
            useNGrams = true;
            usePrev = true;
            useNext = true;
            useTags = true;
            useWordPairs = true;
            wordShape = WordShapeClassifier.WORDSHAPEDAN1;
            useSequences = true;
            usePrevSequences = true;
          }
        } else if (key.equalsIgnoreCase("binnedLengths")) {
          if (val != null) {
            String[] binnedLengthStrs = val.split("[, ]+");
            binnedLengths = new int[binnedLengthStrs.length];
            for (int i = 0; i < binnedLengths.length; i++) {
              binnedLengths[i] = Integer.parseInt(binnedLengthStrs[i]);
            }
          }
        } else if (key.equalsIgnoreCase("makeConsistent")) {
          makeConsistent = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("dump")) {
          dump = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNGrams")) {
          useNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNeighborNGrams")) {
          useNeighborNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("wordFunction")) {
          wordFunction = ReflectionLoading.loadByReflection(val);
        } else if (key.equalsIgnoreCase("conjoinShapeNGrams")) {
          conjoinShapeNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("lowercaseNGrams")) {
          lowercaseNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useIsURL")) {
          useIsURL = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useURLSequences")) {
          useURLSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useEntityTypes")) {
          useEntityTypes = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useEntityRule")) {
          useEntityRule = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useOrdinal")) {
          useOrdinal = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useEntityTypeSequences")) {
          useEntityTypeSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useIsDateRange")) {
          useIsDateRange = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("dehyphenateNGrams")) {
          dehyphenateNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("lowerNewgeneThreshold")) {
          lowerNewgeneThreshold = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePrev")) {
          usePrev = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNext")) {
          useNext = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTags")) {
          useTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordPairs")) {
          useWordPairs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useGazettes")) {
          useGazettes = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("wordShape")) {
          wordShape = WordShapeClassifier.lookupShaper(val);
        } else if (key.equalsIgnoreCase("useShapeStrings")) {
          useShapeStrings = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useGoodForNamesCpC")) {
          useGoodForNamesCpC = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDictionaryConjunctions")) {
          useDictionaryConjunctions = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDictionaryConjunctions3")) {
          useDictionaryConjunctions3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("expandMidDot")) {
          expandMidDot = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSequences")) {
          useSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePrevSequences")) {
          usePrevSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNextSequences")) {
          useNextSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLongSequences")) {
          useLongSequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useBoundarySequences")) {
          useBoundarySequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTaggySequences")) {
          useTaggySequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useExtraTaggySequences")) {
          useExtraTaggySequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTaggySequencesShapeInteraction")) {
          useTaggySequencesShapeInteraction = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("strictlyZeroethOrder")) {
          strictlyZeroethOrder = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("strictlyFirstOrder")) {
          strictlyFirstOrder = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("strictlySecondOrder")) {
          strictlySecondOrder = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("strictlyThirdOrder")) {
          strictlyThirdOrder = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("dontExtendTaggy")) {
          dontExtendTaggy = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("entitySubclassification")) {
          entitySubclassification = val;
        } else if (key.equalsIgnoreCase("useGazettePhrases")) {
          useGazettePhrases = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("phraseGazettes")) {
          StringTokenizer st = new StringTokenizer(val, " ,;\t");
          if (phraseGazettes == null) {
            phraseGazettes = new ArrayList<String>();
          }
          while (st.hasMoreTokens()) {
            phraseGazettes.add(st.nextToken());
          }
        } else if (key.equalsIgnoreCase("useSum")) {
          useSum = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("verboseMode")) {
          verboseMode = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("tolerance")) {
          tolerance = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("maxIterations")) {
          maxIterations = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("exportFeatures")) {
          exportFeatures = val;
        } else if (key.equalsIgnoreCase("printFeatures")) {
          printFeatures = val;
        } else if (key.equalsIgnoreCase("printFeaturesUpto")) {
          printFeaturesUpto = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("lastNameList")) {
          lastNameList = val;
        } else if (key.equalsIgnoreCase("maleNameList")) {
          maleNameList = val;
        } else if (key.equalsIgnoreCase("femaleNameList")) {
          femaleNameList = val;
        } else if (key.equalsIgnoreCase("useSymTags")) {
          useSymTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSymWordPairs")) {
          useSymWordPairs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("printClassifier")) {
          printClassifier = val;
        } else if (key.equalsIgnoreCase("printClassifierParam")) {
          printClassifierParam = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("intern")) {
          intern = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("mergetags")) {
          mergeTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("iobtags")) {
          iobTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useViterbi")) {
          useViterbi = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("intern2")) {
          intern2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("selfTest")) {
          selfTest = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("sloppyGazette")) {
          sloppyGazette = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("cleanGazette")) {
          cleanGazette = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("noMidNGrams")) {
          noMidNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useReverse")) {
          useReverse = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("retainEntitySubclassification")) {
          retainEntitySubclassification = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLemmas")) {
          useLemmas = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePrevNextLemmas")) {
          usePrevNextLemmas = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("normalizeTerms")) {
          normalizeTerms = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("normalizeTimex")) {
          normalizeTimex = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNB")) {
          useNB = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useParenMatching")) {
          useParenMatching = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTypeSeqs")) {
          useTypeSeqs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTypeSeqs2")) {
          useTypeSeqs2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTypeSeqs3")) {
          useTypeSeqs3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDisjunctive")) {
          useDisjunctive = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("disjunctionWidth")) {
          disjunctionWidth = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useDisjunctiveShapeInteraction")) {
          useDisjunctiveShapeInteraction = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWideDisjunctive")) {
          useWideDisjunctive = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("wideDisjunctionWidth")) {
          wideDisjunctionWidth = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useDisjShape")) {
          useDisjShape = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTitle")) {
          useTitle = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("booleanFeatures")) {
          booleanFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useClassFeature")) {
          useClassFeature = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useShapeConjunctions")) {
          useShapeConjunctions = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordTag")) {
          useWordTag = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNPHead")) {
          useNPHead = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNPGovernor")) {
          useNPGovernor = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useHeadGov")) {
          useHeadGov = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLastRealWord")) {
          useLastRealWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNextRealWord")) {
          useNextRealWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useOccurrencePatterns")) {
          useOccurrencePatterns = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTypeySequences")) {
          useTypeySequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("justify")) {
          justify = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("normalize")) {
          normalize = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("priorType")) {
          priorType = val;
        } else if (key.equalsIgnoreCase("sigma")) {
          sigma = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("epsilon")) {
          epsilon = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("beamSize")) {
          beamSize = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("removeTopN")) {
          removeTopN = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("removeTopNPercent")) {
          removeTopNPercent = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("randomizedRatio")) {
          randomizedRatio = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("numTimesRemoveTopN")) {
          numTimesRemoveTopN = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("maxLeft")) {
          maxLeft = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("maxRight")) {
          maxRight = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("maxNGramLeng")) {
          maxNGramLeng = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useGazFeatures")) {
          useGazFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAltGazFeatures")) {
          useAltGazFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMoreGazFeatures")) {
          useMoreGazFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbbr")) {
          useAbbr = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMinimalAbbr")) {
          useMinimalAbbr = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbbr1")) {
          useAbbr1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMinimalAbbr1")) {
          useMinimalAbbr1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("documentReader")) {
          System.err.println("You are using an outdated flag: -documentReader " + val);
          System.err.println("Please use -readerAndWriter instead.");
        } else if (key.equalsIgnoreCase("deleteBlankLines")) {
          deleteBlankLines = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("answerFile")) {
          answerFile = val;
        } else if (key.equalsIgnoreCase("altAnswerFile")) {
          altAnswerFile = val;
        } else if (key.equalsIgnoreCase("loadClassifier")) {
          loadClassifier = val;
        } else if (key.equalsIgnoreCase("loadTextClassifier")) {
          loadTextClassifier = val;
        } else if (key.equalsIgnoreCase("loadJarClassifier")) {
          loadJarClassifier = val;
        } else if (key.equalsIgnoreCase("loadAuxClassifier")) {
          loadAuxClassifier = val;
        } else if (key.equalsIgnoreCase("serializeTo")) {
          serializeTo = val;
        } else if (key.equalsIgnoreCase("serializeToText")) {
          serializeToText = val;
        } else if (key.equalsIgnoreCase("serializeDatasetsDir")) {
          serializeDatasetsDir = val;
        } else if (key.equalsIgnoreCase("loadDatasetsDir")) {
          loadDatasetsDir = val;
        } else if (key.equalsIgnoreCase("pushDir")) {
          pushDir = val;
        } else if (key.equalsIgnoreCase("purgeDatasets")) {
          purgeDatasets = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("keepOBInMemory")) {
          keepOBInMemory = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("fakeDataset")) {
          fakeDataset = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("numDatasetsPerFile")) {
          numDatasetsPerFile = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("trainFile")) {
          trainFile = val;
        } else if (key.equalsIgnoreCase("biasedTrainFile")) {
          biasedTrainFile = val;
        } else if (key.equalsIgnoreCase("classBias")) {
          classBias = val;
        } else if (key.equalsIgnoreCase("confusionMatrix")) {
          confusionMatrix = val;
        } else if (key.equalsIgnoreCase("adaptFile")) {
          adaptFile = val;
        } else if (key.equalsIgnoreCase("devFile")) {
          devFile = val;
        } else if (key.equalsIgnoreCase("testFile")) {
          testFile = val;
        } else if (key.equalsIgnoreCase("outputFile")) {
          outputFile = val;
        } else if (key.equalsIgnoreCase("textFile")) {
          textFile = val;
        } else if (key.equalsIgnoreCase("readStdin")) {
          readStdin = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("initialWeights")) {
          initialWeights = val;
        } else if (key.equalsIgnoreCase("interimOutputFreq")) {
          interimOutputFreq = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("inputEncoding")) {
          inputEncoding = val;
        } else if (key.equalsIgnoreCase("outputEncoding")) {
          outputEncoding = val;
        } else if (key.equalsIgnoreCase("gazette")) {
          useGazettes = true;
          StringTokenizer st = new StringTokenizer(val, " ,;\t");
          if (gazettes == null) {
            gazettes = new ArrayList<String>();
          } // for after deserialization, as gazettes is transient
          while (st.hasMoreTokens()) {
            gazettes.add(st.nextToken());
          }
        } else if (key.equalsIgnoreCase("useQN")) {
          useQN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("QNsize")) {
          QNsize = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("QNsize2")) {
          QNsize2 = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("l1reg")) {
          useQN = false;
          l1reg = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("useFloat")) {
          useFloat = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("trainMap")) {
          System.err.println("trainMap and testMap are no longer valid options - please use map instead.");
          throw new RuntimeException();
        } else if (key.equalsIgnoreCase("testMap")) {
          System.err.println("trainMap and testMap are no longer valid options - please use map instead.");
          throw new RuntimeException();
        } else if (key.equalsIgnoreCase("map")) {
          map = val;
        } else if (key.equalsIgnoreCase("useMoreAbbr")) {
          useMoreAbbr = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePrevVB")) {
          usePrevVB = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNextVB")) {
          useNextVB = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useVB")) {
          if (Boolean.parseBoolean(val)) {
            useVB = true;
            usePrevVB = true;
            useNextVB = true;
          }
        } else if (key.equalsIgnoreCase("useChunks")) {
          useChunks = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useChunkySequences")) {
          useChunkySequences = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("greekifyNGrams")) {
          greekifyNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("restrictTransitionsTimit")) {
          restrictTransitionsTimit = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMoreTags")) {
          useMoreTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useBeginSent")) {
          useBeginSent = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePosition")) {
          usePosition = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useGenia")) {
          useGENIA = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbstr")) {
          useABSTR = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWeb")) {
          useWEB = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAnte")) {
          useANTE = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAcr")) {
          useACR = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTok")) {
          useTOK = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbgene")) {
          useABGENE = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbstrFreqDict")) {
          useABSTRFreqDict = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAbstrFreq")) {
          useABSTRFreq = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFreq")) {
          useFREQ = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usewebfreqdict")) {
          useWEBFreqDict = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("bioSubmitOutput")) {
          bioSubmitOutput = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("subCWGaz")) {
          subCWGaz = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("splitOnHead")) {
          splitOnHead = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("featureCountThreshold")) {
          featureCountThreshold = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useWord")) {
          useWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("memoryThrift")) {
          memoryThrift = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("timitDatum")) {
          timitDatum = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("splitDocuments")) {
          splitDocuments = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("featureWeightThreshold")) {
          featureWeightThreshold = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("backgroundSymbol")) {
          backgroundSymbol = val;
        } else if (key.equalsIgnoreCase("featureFactory")) {
          featureFactory = val;
          if (featureFactory.equalsIgnoreCase("SuperSimpleFeatureFactory")) {
            featureFactory = "edu.stanford.nlp.sequences.SuperSimpleFeatureFactory";
          } else if (featureFactory.equalsIgnoreCase("NERFeatureFactory")) {
            featureFactory = "edu.stanford.nlp.ie.NERFeatureFactory";
          } else if (featureFactory.equalsIgnoreCase("GazNERFeatureFactory")) {
            featureFactory = "edu.stanford.nlp.sequences.GazNERFeatureFactory";
          } else if (featureFactory.equalsIgnoreCase("IncludeAllFeatureFactory")) {
            featureFactory = "edu.stanford.nlp.sequences.IncludeAllFeatureFactory";
          } else if (featureFactory.equalsIgnoreCase("PhraseFeatureFactory")) {
            featureFactory = "edu.stanford.nlp.article.extraction.PhraseFeatureFactory";
          }
  
        } else if (key.equalsIgnoreCase("printXML")) {
          printXML = Boolean.parseBoolean(val); // todo: This appears unused now.
          // Was it replaced by
          // outputFormat?
  
        } else if (key.equalsIgnoreCase("useSeenFeaturesOnly")) {
          useSeenFeaturesOnly = Boolean.parseBoolean(val);
  
          // chinese word-segmenter features
        } else if (key.equalsIgnoreCase("useRadical")) {
          useRadical = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useBigramInTwoClique")) {
          useBigramInTwoClique = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useReverseAffix")) {
          useReverseAffix = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("charHalfWindow")) {
          charHalfWindow = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("purgeFeatures")) {
          purgeFeatures = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("ocrFold")) {
          ocrFold = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("morphFeatureFile")) {
          morphFeatureFile = val;
        } else if (key.equalsIgnoreCase("svmModelFile")) {
          svmModelFile = val;
          /* Dictionary */
        } else if (key.equalsIgnoreCase("useDictleng")) {
          useDictleng = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDict2")) {
          useDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useOutDict2")) {
          useOutDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("outDict2")) {
          outDict2 = val;
        } else if (key.equalsIgnoreCase("useDictCTB2")) {
          useDictCTB2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDictASBC2")) {
          useDictASBC2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDictPK2")) {
          useDictPK2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDictHK2")) {
          useDictHK2 = Boolean.parseBoolean(val);
          /* N-gram flags */
        } else if (key.equalsIgnoreCase("useWord1")) {
          useWord1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWord2")) {
          useWord2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWord3")) {
          useWord3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWord4")) {
          useWord4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useRad1")) {
          useRad1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useRad2")) {
          useRad2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useRad2b")) {
          useRad2b = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordn")) {
          useWordn = Boolean.parseBoolean(val);
          /* affix flags */
        } else if (key.equalsIgnoreCase("useCTBPre1")) {
          useCTBPre1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useCTBSuf1")) {
          useCTBSuf1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useASBCPre1")) {
          useASBCPre1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useASBCSuf1")) {
          useASBCSuf1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useHKPre1")) {
          useHKPre1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useHKSuf1")) {
          useHKSuf1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePKPre1")) {
          usePKPre1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePKSuf1")) {
          usePKSuf1 = Boolean.parseBoolean(val);
          /* POS flags */
        } else if (key.equalsIgnoreCase("useCTBChar2")) {
          useCTBChar2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePrediction")) {
          usePrediction = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useASBCChar2")) {
          useASBCChar2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useHKChar2")) {
          useHKChar2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePKChar2")) {
          usePKChar2 = Boolean.parseBoolean(val);
          /* Rule flag */
        } else if (key.equalsIgnoreCase("useRule2")) {
          useRule2 = Boolean.parseBoolean(val);
          /* ASBC and HK */
        } else if (key.equalsIgnoreCase("useBig5")) {
          useBig5 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegDict2")) {
          useNegDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegDict3")) {
          useNegDict3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegDict4")) {
          useNegDict4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegCTBDict2")) {
          useNegCTBDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegCTBDict3")) {
          useNegCTBDict3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegCTBDict4")) {
          useNegCTBDict4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegASBCDict2")) {
          useNegASBCDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegASBCDict3")) {
          useNegASBCDict3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegASBCDict4")) {
          useNegASBCDict4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegPKDict2")) {
          useNegPKDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegPKDict3")) {
          useNegPKDict3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegPKDict4")) {
          useNegPKDict4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegHKDict2")) {
          useNegHKDict2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegHKDict3")) {
          useNegHKDict3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNegHKDict4")) {
          useNegHKDict4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePre")) {
          usePre = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSuf")) {
          useSuf = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useRule")) {
          useRule = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAs")) {
          useAs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePk")) {
          usePk = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useHk")) {
          useHk = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMsr")) {
          useMsr = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMSRChar2")) {
          useMSRChar2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesC4gram")) {
          useFeaturesC4gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesC5gram")) {
          useFeaturesC5gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesC6gram")) {
          useFeaturesC6gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesCpC4gram")) {
          useFeaturesCpC4gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesCpC5gram")) {
          useFeaturesCpC5gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFeaturesCpC6gram")) {
          useFeaturesCpC6gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useUnicodeType")) {
          useUnicodeType = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useUnicodeBlock")) {
          useUnicodeBlock = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useUnicodeType4gram")) {
          useUnicodeType4gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useUnicodeType5gram")) {
          useUnicodeType5gram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useShapeStrings1")) {
          useShapeStrings1 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useShapeStrings3")) {
          useShapeStrings3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useShapeStrings4")) {
          useShapeStrings4 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useShapeStrings5")) {
          useShapeStrings5 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordUTypeConjunctions2")) {
          useWordUTypeConjunctions2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordUTypeConjunctions3")) {
          useWordUTypeConjunctions3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordShapeConjunctions2")) {
          useWordShapeConjunctions2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordShapeConjunctions3")) {
          useWordShapeConjunctions3 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMidDotShape")) {
          useMidDotShape = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("augmentedDateChars")) {
          augmentedDateChars = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("suppressMidDotPostprocessing")) {
          suppressMidDotPostprocessing = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("printNR")) {
          printNR = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("use4Clique")) {
          use4Clique = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFilter")) {
          useFilter = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("largeChSegFile")) {
          largeChSegFile = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("keepEnglishWhitespaces")) {
          keepEnglishWhitespaces = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("keepAllWhitespaces")) {
          keepAllWhitespaces = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("sighanPostProcessing")) {
          sighanPostProcessing = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useChPos")) {
          useChPos = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("sighanCorporaDict")) {
          sighanCorporaDict = val;
          // end chinese word-segmenter features
        } else if (key.equalsIgnoreCase("useObservedSequencesOnly")) {
          useObservedSequencesOnly = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("maxDocSize")) {
          maxDocSize = Integer.parseInt(val);
          splitDocuments = true;
        } else if (key.equalsIgnoreCase("printProbs")) {
          printProbs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("printFirstOrderProbs")) {
          printFirstOrderProbs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("saveFeatureIndexToDisk")) {
          saveFeatureIndexToDisk = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("removeBackgroundSingletonFeatures")) {
          removeBackgroundSingletonFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("doGibbs")) {
          doGibbs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNERPrior")) {
          useNERPrior = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAcqPrior")) {
          useAcqPrior = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSemPrior")) {
          useSemPrior = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMUCFeatures")) {
          useMUCFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("initViterbi")) {
          initViterbi = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("checkNameList")) {
          checkNameList = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFirstWord")) {
          useFirstWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useUnknown")) {
          useUnknown = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("cacheNGrams")) {
          cacheNGrams = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useNumberFeature")) {
          useNumberFeature = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("annealingRate")) {
          annealingRate = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("annealingType")) {
          if (val.equalsIgnoreCase("linear") || val.equalsIgnoreCase("exp") || val.equalsIgnoreCase("exponential")) {
            annealingType = val;
          } else {
            System.err.println("unknown annealingType: " + val + ".  Please use linear|exp|exponential");
          }
        } else if (key.equalsIgnoreCase("numSamples")) {
          numSamples = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("inferenceType")) {
          inferenceType = val;
        } else if (key.equalsIgnoreCase("loadProcessedData")) {
          loadProcessedData = val;
        } else if (key.equalsIgnoreCase("normalizationTable")) {
          normalizationTable = val;
        } else if (key.equalsIgnoreCase("dictionary")) {
          // don't set if empty string or spaces or true: revert it to null
          // special case so can empty out dictionary list on command line!
          val = val.trim();
          if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
            dictionary = val;
          } else {
            dictionary = null;
          }
        } else if (key.equalsIgnoreCase("serDictionary")) {
          // don't set if empty string or spaces or true: revert it to null
          // special case so can empty out dictionary list on command line!
          val = val.trim();
          if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
            serializedDictionary = val;
          } else {
            serializedDictionary = null;
          }
        } else if (key.equalsIgnoreCase("dictionary2")) {
          // don't set if empty string or spaces or true: revert it to null
          // special case so can empty out dictionary list on command line!
          val = val.trim();
          if (val.length() > 0 && !"true".equals(val) && !"null".equals(val) && !"false".equals("val")) {
            dictionary2 = val;
          } else {
            dictionary2 = null;
          }
        } else if (key.equalsIgnoreCase("normTableEncoding")) {
          normTableEncoding = val;
        } else if (key.equalsIgnoreCase("useLemmaAsWord")) {
          useLemmaAsWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("type")) {
          type = val;
        } else if (key.equalsIgnoreCase("readerAndWriter")) {
          readerAndWriter = val;
        } else if (key.equalsIgnoreCase("plainTextDocumentReaderAndWriter")) {
          plainTextDocumentReaderAndWriter = val;
        } else if (key.equalsIgnoreCase("gazFilesFile")) {
          gazFilesFile = val;
        } else if (key.equalsIgnoreCase("baseTrainDir")) {
          baseTrainDir = val;
        } else if (key.equalsIgnoreCase("baseTestDir")) {
          baseTestDir = val;
        } else if (key.equalsIgnoreCase("trainFiles")) {
          trainFiles = val;
        } else if (key.equalsIgnoreCase("trainFileList")) {
          trainFileList = val;
        } else if (key.equalsIgnoreCase("trainDirs")) {
          trainDirs = val;
        } else if (key.equalsIgnoreCase("testDirs")) {
          testDirs = val;
        } else if (key.equalsIgnoreCase("testFiles")) {
          testFiles = val;
        } else if (key.equalsIgnoreCase("usePrediction2")) {
          usePrediction2 = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useObservedFeaturesOnly")) {
          useObservedFeaturesOnly = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("iobWrapper")) {
          iobWrapper = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useDistSim")) {
          useDistSim = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("casedDistSim")) {
          casedDistSim = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("distSimFileFormat")) {
          distSimFileFormat = val;
        } else if (key.equalsIgnoreCase("distSimMaxBits")) {
          distSimMaxBits = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("numberEquivalenceDistSim")) {
          numberEquivalenceDistSim = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("unknownWordDistSimClass")) {
          unknownWordDistSimClass = val;
        } else if (key.equalsIgnoreCase("useOnlySeenWeights")) {
          useOnlySeenWeights = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("predProp")) {
          predProp = val;
        } else if (key.equalsIgnoreCase("distSimLexicon")) {
          distSimLexicon = val;
        } else if (key.equalsIgnoreCase("useSegmentation")) {
          useSegmentation = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useInternal")) {
          useInternal = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useExternal")) {
          useExternal = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useEitherSideWord")) {
          useEitherSideWord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useEitherSideDisjunctive")) {
          useEitherSideDisjunctive = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("featureDiffThresh")) {
          featureDiffThresh = Double.parseDouble(val);
          if (props.getProperty("numTimesPruneFeatures") == null) {
            numTimesPruneFeatures = 1;
          }
        } else if (key.equalsIgnoreCase("numTimesPruneFeatures")) {
          numTimesPruneFeatures = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("newgeneThreshold")) {
          newgeneThreshold = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("adaptFile")) {
          adaptFile = val;
        } else if (key.equalsIgnoreCase("doAdaptation")) {
          doAdaptation = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("selfTrainFile")) {
          selfTrainFile = val;
        } else if (key.equalsIgnoreCase("selfTrainIterations")) {
          selfTrainIterations = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("selfTrainWindowSize")) {
          selfTrainWindowSize = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("selfTrainConfidenceThreshold")) {
          selfTrainConfidenceThreshold = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("numFolds")) {
          numFolds = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("startFold")) {
          startFold = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("endFold")) {
          endFold = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("adaptSigma")) {
          adaptSigma = Double.parseDouble(val);
        } else if (key.startsWith("prop") && !key.equals("prop")) {
          comboProps.add(val);
        } else if (key.equalsIgnoreCase("outputFormat")) {
          outputFormat = val;
        } else if (key.equalsIgnoreCase("useSMD")) {
          useSMD = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useScaledSGD")) {
          useScaledSGD = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("scaledSGDMethod")) {
          scaledSGDMethod = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("tuneSGD")) {
          tuneSGD = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("StochasticCalculateMethod")) {
          if (val.equalsIgnoreCase("AlgorithmicDifferentiation")) {
            stochasticMethod = StochasticCalculateMethods.AlgorithmicDifferentiation;
          } else if (val.equalsIgnoreCase("IncorporatedFiniteDifference")) {
            stochasticMethod = StochasticCalculateMethods.IncorporatedFiniteDifference;
          } else if (val.equalsIgnoreCase("ExternalFinitedifference")) {
            stochasticMethod = StochasticCalculateMethods.ExternalFiniteDifference;
          }
        } else if (key.equalsIgnoreCase("initialGain")) {
          initialGain = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("stochasticBatchSize")) {
          stochasticBatchSize = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("SGD2QNhessSamples")) {
          SGD2QNhessSamples = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useSGD")) {
          useSGD = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useInPlaceSGD")) {
          useInPlaceSGD = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSGDtoQN")) {
          useSGDtoQN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("SGDPasses")) {
          SGDPasses = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("QNPasses")) {
          QNPasses = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("gainSGD")) {
          gainSGD = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("useHybrid")) {
          useHybrid = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("hybridCutoffIteration")) {
          hybridCutoffIteration = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useStochasticQN")) {
          useStochasticQN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("outputIterationsToFile")) {
          outputIterationsToFile = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("testObjFunction")) {
          testObjFunction = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("testVariance")) {
          testVariance = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("CRForder")) {
          CRForder = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("CRFwindow")) {
          CRFwindow = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("testHessSamples")) {
          testHessSamples = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("estimateInitial")) {
          estimateInitial = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("printLabelValue")) {
          printLabelValue = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("searchGraphPrefix")) {
          searchGraphPrefix = val;
        } else if (key.equalsIgnoreCase("searchGraphPrune")) {
          searchGraphPrune = Double.parseDouble(val);
        } else if (key.equalsIgnoreCase("kBest")) {
          useKBest = true;
          kBest = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useRobustQN")) {
          useRobustQN = true;
        } else if (key.equalsIgnoreCase("combo")) {
          combo = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("verboseForTrueCasing")) {
          verboseForTrueCasing = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("trainHierarchical")) {
          trainHierarchical = val;
        } else if (key.equalsIgnoreCase("domain")) {
          domain = val;
        } else if (key.equalsIgnoreCase("baseline")) {
          baseline = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("doFE")) {
          doFE = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("restrictLabels")) {
          restrictLabels = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("transferSigmas")) {
          transferSigmas = val;
        } else if (key.equalsIgnoreCase("announceObjectBankEntries")) {
          announceObjectBankEntries = true;
        } else if (key.equalsIgnoreCase("usePos")) {
          usePos = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAgreement")) {
          useAgreement = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAccCase")) {
          useAccCase = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useInna")) {
          useInna = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useConcord")) {
          useConcord = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useFirstNgram")) {
          useFirstNgram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLastNgram")) {
          useLastNgram = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("collapseNN")) {
          collapseNN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTagsCpC")) {
          useTagsCpC = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTagsCpCp2C")) {
          useTagsCpCp2C = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTagsCpCp2Cp3C")) {
          useTagsCpCp2Cp3C = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTagsCpCp2Cp3Cp4C")) {
          useTagsCpCp2Cp3Cp4C = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("numTags")) {
          numTags = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useConjBreak")) {
          useConjBreak = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAuxPairs")) {
          useAuxPairs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePPVBPairs")) {
          usePPVBPairs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useAnnexing")) {
          useAnnexing = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useTemporalNN")) {
          useTemporalNN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("markProperNN")) {
          markProperNN = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePath")) {
          usePath = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("markMasdar")) {
          markMasdar = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("innaPPAttach")) {
          innaPPAttach = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSVO")) {
          useSVO = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("mixedCaseMapFile")) {
          mixedCaseMapFile = val;
        } else if (key.equalsIgnoreCase("auxTrueCaseModels")) {
          auxTrueCaseModels = val;
        } else if (key.equalsIgnoreCase("use2W")) {
          use2W = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLC")) {
          useLC = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useYetMoreCpCShapes")) {
          useYetMoreCpCShapes = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useIfInteger")) {
          useIfInteger = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("twoStage")) {
          twoStage = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("evaluateIters")) {
          evaluateIters = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("evalCmd")) {
          evalCmd = val;
        } else if (key.equalsIgnoreCase("evaluateTrain")) {
          evaluateTrain = Boolean.parseBoolean(val);
  
        } else if (key.equalsIgnoreCase("evaluateIOB")) {
          evaluateIOB = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("tuneSampleSize")) {
          tuneSampleSize = Integer.parseInt(val);
        } else if (key.equalsIgnoreCase("useTopics")) {
          useTopics = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePhraseFeatures")) {
          usePhraseFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePhraseWords")) {
          usePhraseWords = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePhraseWordTags")) {
          usePhraseWordTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("usePhraseWordSpecialTags")) {
          usePhraseWordSpecialTags = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useProtoFeatures")) {
          useProtoFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useWordnetFeatures")) {
          useWordnetFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("wikiFeatureDbFile")) {
          wikiFeatureDbFile = val;
        } else if (key.equalsIgnoreCase("tokenizerOptions")) {
          tokenizerOptions = val;
        } else if (key.equalsIgnoreCase("useCommonWordsFeature")) {
          useCommonWordsFeature = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useYear")) {
          useYear = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useSentenceNumber")) {
          useSentenceNumber = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLabelSource")) {
          useLabelSource = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("tokenFactory")) {
          tokenFactory = val;
        } else if (key.equalsIgnoreCase("tokensAnnotationClassName")) {
          tokensAnnotationClassName = val;
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzer")) {
            useLVMorphoAnalyzer = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("LVMorphoAnalyzerTag")) {
            lvMorphoAnalyzerTag = val;
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzerPOS")) {
            useLVMorphoAnalyzerPOS = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzerTag")) {
            useLVMorphoAnalyzerTag = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzerPrev")) {
            useLVMorphoAnalyzerPrev = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzerNext")) {
            useLVMorphoAnalyzerNext = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useLVMorphoAnalyzerItemIDs")) {
            useLVMorphoAnalyzerItemIDs = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMorphologyFeatures")) {
      	  useMorphologyFeatures = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMorphoCase")) {
      	  useMorphoCase = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMorphoPOS")) {
      	  useMorphoPOS = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMorphoLetaLemma")) {
      	  useMorphoLetaLemma = Boolean.parseBoolean(val);
        } else if (key.equalsIgnoreCase("useMorphoNumber")) {
      	  useMorphoNumber = Boolean.parseBoolean(val);
  
          // ADD VALUE ABOVE HERE
        } else if (key.length() > 0 && !key.equals("prop")) {
          System.err.println("Unknown property: |" + key + '|');
        }
      }
      if (startFold > numFolds) {
        System.err.println("startFold > numFolds -> setting startFold to 1");
        startFold = 1;
      }
      if (endFold > numFolds) {
        System.err.println("endFold > numFolds -> setting to numFolds");
        endFold = numFolds;
      }
  
      if (combo) {
        splitDocuments = false;
      }
  
      stringRep = sb.toString();
    }