001    package ch.uzh.ifi.attempto.aceeditor.grammar;
002    
003    import java.util.ArrayList;
004    import java.util.HashMap;
005    
006    import ch.uzh.ifi.attempto.chartparser.Nonterminal;
007    import ch.uzh.ifi.attempto.chartparser.Rule;
008    import ch.uzh.ifi.attempto.chartparser.StringRef;
009    import ch.uzh.ifi.attempto.chartparser.Terminal;
010    import ch.uzh.ifi.attempto.chartparser.Category;
011    import ch.uzh.ifi.attempto.chartparser.FeatureMap;
012    
013    /**
014     * This grammar class is automatically generated by the SWI Prolog program "generate_java.pl".
015     */
016    @SuppressWarnings("all")
017    public class ACEGrammar extends ch.uzh.ifi.attempto.chartparser.Grammar {
018            
019            /**
020             * Creates a new grammar object.
021             */
022            public ACEGrammar() {
023                    super("text");
024                    ArrayList<Category> l = new ArrayList<Category>();
025                    Category c;
026                    HashMap<Integer, StringRef> featureHash = new HashMap<Integer, StringRef>();
027                    
028                    // test=>declaration, fill
029                    l.clear();
030                    featureHash.clear();
031                    c = new Nonterminal("test");
032                    l.add(c);
033                    c = new Nonterminal("declaration");
034                    l.add(c);
035                    c = new Nonterminal("fill");
036                    l.add(c);
037                    addRule(new Rule(l, true));
038                    
039                    // test=>question, fill
040                    l.clear();
041                    featureHash.clear();
042                    c = new Nonterminal("test");
043                    l.add(c);
044                    c = new Nonterminal("question");
045                    l.add(c);
046                    c = new Nonterminal("fill");
047                    l.add(c);
048                    addRule(new Rule(l, true));
049                    
050                    // fill=>[]
051                    l.clear();
052                    featureHash.clear();
053                    c = new Nonterminal("fill");
054                    l.add(c);
055                    addRule(new Rule(l, true));
056                    
057                    // fill=>[-], fill
058                    l.clear();
059                    featureHash.clear();
060                    c = new Nonterminal("fill");
061                    l.add(c);
062                    c = new Terminal("-");
063                    l.add(c);
064                    c = new Nonterminal("fill");
065                    l.add(c);
066                    addRule(new Rule(l, true));
067                    
068                    // text=>[]
069                    l.clear();
070                    featureHash.clear();
071                    c = new Nonterminal("text");
072                    l.add(c);
073                    addRule(new Rule(l, true));
074                    
075                    // text=>declaration, text
076                    l.clear();
077                    featureHash.clear();
078                    c = new Nonterminal("text");
079                    l.add(c);
080                    c = new Nonterminal("declaration");
081                    l.add(c);
082                    c = new Nonterminal("text");
083                    l.add(c);
084                    addRule(new Rule(l, true));
085                    
086                    // text=>question
087                    l.clear();
088                    featureHash.clear();
089                    c = new Nonterminal("text");
090                    l.add(c);
091                    c = new Nonterminal("question");
092                    l.add(c);
093                    addRule(new Rule(l, true));
094                    
095                    // declaration=>sentence, ['.']
096                    l.clear();
097                    featureHash.clear();
098                    c = new Nonterminal("declaration");
099                    l.add(c);
100                    c = new Nonterminal("sentence");
101                    l.add(c);
102                    c = new Terminal(".");
103                    l.add(c);
104                    addRule(new Rule(l, true));
105                    
106                    // question=>simple_sentence_2(whin:minus, whout:plus), [?]
107                    l.clear();
108                    featureHash.clear();
109                    c = new Nonterminal("question");
110                    l.add(c);
111                    c = new Nonterminal("simple_sentence_2");
112                    c.setFeature("whin", new StringRef("minus"));
113                    c.setFeature("whout", new StringRef("plus"));
114                    l.add(c);
115                    c = new Terminal("?");
116                    l.add(c);
117                    addRule(new Rule(l, true));
118                    
119                    // sentence=>sentence_coord_1
120                    l.clear();
121                    featureHash.clear();
122                    c = new Nonterminal("sentence");
123                    l.add(c);
124                    c = new Nonterminal("sentence_coord_1");
125                    l.add(c);
126                    addRule(new Rule(l, true));
127                    
128                    // sentence~>['for every'], noun_constr, sentence_coord_1
129                    l.clear();
130                    featureHash.clear();
131                    c = new Nonterminal("sentence");
132                    l.add(c);
133                    c = new Terminal("for every");
134                    l.add(c);
135                    c = new Nonterminal("noun_constr");
136                    l.add(c);
137                    c = new Nonterminal("sentence_coord_1");
138                    l.add(c);
139                    addRule(new Rule(l, false));
140                    
141                    // sentence~>[if], sentence_coord_1, [then], sentence_coord_1
142                    l.clear();
143                    featureHash.clear();
144                    c = new Nonterminal("sentence");
145                    l.add(c);
146                    c = new Terminal("if");
147                    l.add(c);
148                    c = new Nonterminal("sentence_coord_1");
149                    l.add(c);
150                    c = new Terminal("then");
151                    l.add(c);
152                    c = new Nonterminal("sentence_coord_1");
153                    l.add(c);
154                    addRule(new Rule(l, false));
155                    
156                    // sentence_coord_1=>sentence_coord_2
157                    l.clear();
158                    featureHash.clear();
159                    c = new Nonterminal("sentence_coord_1");
160                    l.add(c);
161                    c = new Nonterminal("sentence_coord_2");
162                    l.add(c);
163                    addRule(new Rule(l, true));
164                    
165                    // sentence_coord_1~>sentence_coord_2, [or], sentence_coord_1
166                    l.clear();
167                    featureHash.clear();
168                    c = new Nonterminal("sentence_coord_1");
169                    l.add(c);
170                    c = new Nonterminal("sentence_coord_2");
171                    l.add(c);
172                    c = new Terminal("or");
173                    l.add(c);
174                    c = new Nonterminal("sentence_coord_1");
175                    l.add(c);
176                    addRule(new Rule(l, false));
177                    
178                    // sentence_coord_2=>simple_sentence
179                    l.clear();
180                    featureHash.clear();
181                    c = new Nonterminal("sentence_coord_2");
182                    l.add(c);
183                    c = new Nonterminal("simple_sentence");
184                    l.add(c);
185                    addRule(new Rule(l, true));
186                    
187                    // sentence_coord_2=>simple_sentence, [and], sentence_coord_2
188                    l.clear();
189                    featureHash.clear();
190                    c = new Nonterminal("sentence_coord_2");
191                    l.add(c);
192                    c = new Nonterminal("simple_sentence");
193                    l.add(c);
194                    c = new Terminal("and");
195                    l.add(c);
196                    c = new Nonterminal("sentence_coord_2");
197                    l.add(c);
198                    addRule(new Rule(l, true));
199                    
200                    // simple_sentence~>['it is false that'], simple_sentence_2(whin:minus, whout:minus)
201                    l.clear();
202                    featureHash.clear();
203                    c = new Nonterminal("simple_sentence");
204                    l.add(c);
205                    c = new Terminal("it is false that");
206                    l.add(c);
207                    c = new Nonterminal("simple_sentence_2");
208                    c.setFeature("whin", new StringRef("minus"));
209                    c.setFeature("whout", new StringRef("minus"));
210                    l.add(c);
211                    addRule(new Rule(l, false));
212                    
213                    // simple_sentence=>['there is'], nounphrase(exist:plus, def:minus, pl:minus, whin:minus, whout:minus)
214                    l.clear();
215                    featureHash.clear();
216                    c = new Nonterminal("simple_sentence");
217                    l.add(c);
218                    c = new Terminal("there is");
219                    l.add(c);
220                    c = new Nonterminal("nounphrase");
221                    c.setFeature("exist", new StringRef("plus"));
222                    c.setFeature("def", new StringRef("minus"));
223                    c.setFeature("pl", new StringRef("minus"));
224                    c.setFeature("whin", new StringRef("minus"));
225                    c.setFeature("whout", new StringRef("minus"));
226                    l.add(c);
227                    addRule(new Rule(l, true));
228                    
229                    // simple_sentence=>['there is'], nounphrase(exist:plus, def:minus, pl:minus, whin:minus, whout:minus), ['such that'], simple_sentence
230                    l.clear();
231                    featureHash.clear();
232                    c = new Nonterminal("simple_sentence");
233                    l.add(c);
234                    c = new Terminal("there is");
235                    l.add(c);
236                    c = new Nonterminal("nounphrase");
237                    c.setFeature("exist", new StringRef("plus"));
238                    c.setFeature("def", new StringRef("minus"));
239                    c.setFeature("pl", new StringRef("minus"));
240                    c.setFeature("whin", new StringRef("minus"));
241                    c.setFeature("whout", new StringRef("minus"));
242                    l.add(c);
243                    c = new Terminal("such that");
244                    l.add(c);
245                    c = new Nonterminal("simple_sentence");
246                    l.add(c);
247                    addRule(new Rule(l, true));
248                    
249                    // simple_sentence=>['there are'], nounphrase(exist:plus, def:minus, pl:plus, whin:minus, whout:minus)
250                    l.clear();
251                    featureHash.clear();
252                    c = new Nonterminal("simple_sentence");
253                    l.add(c);
254                    c = new Terminal("there are");
255                    l.add(c);
256                    c = new Nonterminal("nounphrase");
257                    c.setFeature("exist", new StringRef("plus"));
258                    c.setFeature("def", new StringRef("minus"));
259                    c.setFeature("pl", new StringRef("plus"));
260                    c.setFeature("whin", new StringRef("minus"));
261                    c.setFeature("whout", new StringRef("minus"));
262                    l.add(c);
263                    addRule(new Rule(l, true));
264                    
265                    // simple_sentence=>simple_sentence_2(whin:minus, whout:minus)
266                    l.clear();
267                    featureHash.clear();
268                    c = new Nonterminal("simple_sentence");
269                    l.add(c);
270                    c = new Nonterminal("simple_sentence_2");
271                    c.setFeature("whin", new StringRef("minus"));
272                    c.setFeature("whout", new StringRef("minus"));
273                    l.add(c);
274                    addRule(new Rule(l, true));
275                    
276                    // simple_sentence_2(whin:A, whout:B)=>nounphrase(exist:plus, pl:C, whin:A, whout:D), verbphrase_coord_1(pl:C, whin:D, whout:B)
277                    l.clear();
278                    featureHash.clear();
279                    c = new Nonterminal("simple_sentence_2");
280                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
281                    setFeature(c.getFeatureMap(), "whout", 1, featureHash);
282                    l.add(c);
283                    c = new Nonterminal("nounphrase");
284                    c.setFeature("exist", new StringRef("plus"));
285                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
286                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
287                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
288                    l.add(c);
289                    c = new Nonterminal("verbphrase_coord_1");
290                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
291                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
292                    setFeature(c.getFeatureMap(), "whout", 1, featureHash);
293                    l.add(c);
294                    addRule(new Rule(l, true));
295                    
296                    // simple_sentence_2(whin:A, whout:B)~>nounphrase(exist:minus, whin:A, whout:C), verbphrase_coord_1(pl:minus, whin:C, whout:B)
297                    l.clear();
298                    featureHash.clear();
299                    c = new Nonterminal("simple_sentence_2");
300                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
301                    setFeature(c.getFeatureMap(), "whout", 1, featureHash);
302                    l.add(c);
303                    c = new Nonterminal("nounphrase");
304                    c.setFeature("exist", new StringRef("minus"));
305                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
306                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
307                    l.add(c);
308                    c = new Nonterminal("verbphrase_coord_1");
309                    c.setFeature("pl", new StringRef("minus"));
310                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
311                    setFeature(c.getFeatureMap(), "whout", 1, featureHash);
312                    l.add(c);
313                    addRule(new Rule(l, false));
314                    
315                    // verbphrase_coord_1(pl:A, whin:B, whout:C)=>verbphrase_coord_2(pl:A, whin:B, whout:C)
316                    l.clear();
317                    featureHash.clear();
318                    c = new Nonterminal("verbphrase_coord_1");
319                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
320                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
321                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
322                    l.add(c);
323                    c = new Nonterminal("verbphrase_coord_2");
324                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
325                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
326                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
327                    l.add(c);
328                    addRule(new Rule(l, true));
329                    
330                    // verbphrase_coord_1(pl:A, whin:B, whout:C)~>verbphrase_coord_2(pl:A, whin:B, whout:D), [or], verbphrase_coord_1(pl:A, whin:D, whout:C)
331                    l.clear();
332                    featureHash.clear();
333                    c = new Nonterminal("verbphrase_coord_1");
334                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
335                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
336                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
337                    l.add(c);
338                    c = new Nonterminal("verbphrase_coord_2");
339                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
340                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
341                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
342                    l.add(c);
343                    c = new Terminal("or");
344                    l.add(c);
345                    c = new Nonterminal("verbphrase_coord_1");
346                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
347                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
348                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
349                    l.add(c);
350                    addRule(new Rule(l, false));
351                    
352                    // verbphrase_coord_2(pl:A, whin:B, whout:C)=>vp_cut(pl:A, whin:B, whout:C)
353                    l.clear();
354                    featureHash.clear();
355                    c = new Nonterminal("verbphrase_coord_2");
356                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
357                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
358                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
359                    l.add(c);
360                    c = new Nonterminal("vp_cut");
361                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
362                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
363                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
364                    l.add(c);
365                    addRule(new Rule(l, true));
366                    
367                    // verbphrase_coord_2(pl:A, whin:B, whout:C)=>vp_cut(pl:A, whin:B, whout:D), [and], verbphrase_coord_2(pl:A, whin:D, whout:C)
368                    l.clear();
369                    featureHash.clear();
370                    c = new Nonterminal("verbphrase_coord_2");
371                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
372                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
373                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
374                    l.add(c);
375                    c = new Nonterminal("vp_cut");
376                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
377                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
378                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
379                    l.add(c);
380                    c = new Terminal("and");
381                    l.add(c);
382                    c = new Nonterminal("verbphrase_coord_2");
383                    setFeature(c.getFeatureMap(), "pl", 0, featureHash);
384                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
385                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
386                    l.add(c);
387                    addRule(new Rule(l, true));
388                    
389                    // vp_cut(rel:A, pl:B, whin:C, whout:D)=>vp(exists:plus, rel:A, pl:B, whin:C, whout:D)
390                    l.clear();
391                    featureHash.clear();
392                    c = new Nonterminal("vp_cut");
393                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
394                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
395                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
396                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
397                    l.add(c);
398                    c = new Nonterminal("vp");
399                    c.setFeature("exists", new StringRef("plus"));
400                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
401                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
402                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
403                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
404                    l.add(c);
405                    addRule(new Rule(l, true));
406                    
407                    // vp_cut(rel:A, pl:B, whin:C, whout:D)~>vp(exists:minus, rel:A, pl:B, whin:C, whout:D)
408                    l.clear();
409                    featureHash.clear();
410                    c = new Nonterminal("vp_cut");
411                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
412                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
413                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
414                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
415                    l.add(c);
416                    c = new Nonterminal("vp");
417                    c.setFeature("exists", new StringRef("minus"));
418                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
419                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
420                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
421                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
422                    l.add(c);
423                    addRule(new Rule(l, false));
424                    
425                    // vp(exists:A, rel:B, pl:C, whin:D, whout:E)=>auxiliary(be:F, exists:A, pl:C), vbar(be:F, exists:A, pl:C, rel:B, vform:inf, embv:G, copula:H, whin:D, whout:I), v_modifiers(embv:G, copula:H, whin:I, whout:E)
426                    l.clear();
427                    featureHash.clear();
428                    c = new Nonterminal("vp");
429                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
430                    setFeature(c.getFeatureMap(), "rel", 1, featureHash);
431                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
432                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
433                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
434                    l.add(c);
435                    c = new Nonterminal("auxiliary");
436                    setFeature(c.getFeatureMap(), "be", 5, featureHash);
437                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
438                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
439                    l.add(c);
440                    c = new Nonterminal("vbar");
441                    setFeature(c.getFeatureMap(), "be", 5, featureHash);
442                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
443                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
444                    setFeature(c.getFeatureMap(), "rel", 1, featureHash);
445                    c.setFeature("vform", new StringRef("inf"));
446                    setFeature(c.getFeatureMap(), "embv", 6, featureHash);
447                    setFeature(c.getFeatureMap(), "copula", 7, featureHash);
448                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
449                    setFeature(c.getFeatureMap(), "whout", 8, featureHash);
450                    l.add(c);
451                    c = new Nonterminal("v_modifiers");
452                    setFeature(c.getFeatureMap(), "embv", 6, featureHash);
453                    setFeature(c.getFeatureMap(), "copula", 7, featureHash);
454                    setFeature(c.getFeatureMap(), "whin", 8, featureHash);
455                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
456                    l.add(c);
457                    addRule(new Rule(l, true));
458                    
459                    // vp(exists:plus, rel:A, pl:B, whin:C, whout:D)=>vbar(be:minus, exists:plus, pl:B, rel:A, vform:fin, embv:E, copula:F, whin:C, whout:G), v_modifiers(embv:E, copula:F, whin:G, whout:D)
460                    l.clear();
461                    featureHash.clear();
462                    c = new Nonterminal("vp");
463                    c.setFeature("exists", new StringRef("plus"));
464                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
465                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
466                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
467                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
468                    l.add(c);
469                    c = new Nonterminal("vbar");
470                    c.setFeature("be", new StringRef("minus"));
471                    c.setFeature("exists", new StringRef("plus"));
472                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
473                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
474                    c.setFeature("vform", new StringRef("fin"));
475                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
476                    setFeature(c.getFeatureMap(), "copula", 5, featureHash);
477                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
478                    setFeature(c.getFeatureMap(), "whout", 6, featureHash);
479                    l.add(c);
480                    c = new Nonterminal("v_modifiers");
481                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
482                    setFeature(c.getFeatureMap(), "copula", 5, featureHash);
483                    setFeature(c.getFeatureMap(), "whin", 6, featureHash);
484                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
485                    l.add(c);
486                    addRule(new Rule(l, true));
487                    
488                    // vbar(be:minus, exists:A, pl:B, vform:C, copula:minus, whin:D, whout:D)=>verb(vsubcat:itr, be:minus, pl:B, exists:A, vform:C)
489                    l.clear();
490                    featureHash.clear();
491                    c = new Nonterminal("vbar");
492                    c.setFeature("be", new StringRef("minus"));
493                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
494                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
495                    setFeature(c.getFeatureMap(), "vform", 2, featureHash);
496                    c.setFeature("copula", new StringRef("minus"));
497                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
498                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
499                    l.add(c);
500                    c = new Nonterminal("verb");
501                    c.setFeature("vsubcat", new StringRef("itr"));
502                    c.setFeature("be", new StringRef("minus"));
503                    setFeature(c.getFeatureMap(), "pl", 1, featureHash);
504                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
505                    setFeature(c.getFeatureMap(), "vform", 2, featureHash);
506                    l.add(c);
507                    addRule(new Rule(l, true));
508                    
509                    // vbar(be:minus, exists:A, rel:B, pl:C, vform:D, embv:E, copula:minus, whin:F, whout:G)=>verb(vsubcat:tr, be:minus, pl:C, exists:A, vform:D), nounphrase_cut(rel:B, vsubcat:tr, embv:E, whin:F, whout:G)
510                    l.clear();
511                    featureHash.clear();
512                    c = new Nonterminal("vbar");
513                    c.setFeature("be", new StringRef("minus"));
514                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
515                    setFeature(c.getFeatureMap(), "rel", 1, featureHash);
516                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
517                    setFeature(c.getFeatureMap(), "vform", 3, featureHash);
518                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
519                    c.setFeature("copula", new StringRef("minus"));
520                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
521                    setFeature(c.getFeatureMap(), "whout", 6, featureHash);
522                    l.add(c);
523                    c = new Nonterminal("verb");
524                    c.setFeature("vsubcat", new StringRef("tr"));
525                    c.setFeature("be", new StringRef("minus"));
526                    setFeature(c.getFeatureMap(), "pl", 2, featureHash);
527                    setFeature(c.getFeatureMap(), "exists", 0, featureHash);
528                    setFeature(c.getFeatureMap(), "vform", 3, featureHash);
529                    l.add(c);
530                    c = new Nonterminal("nounphrase_cut");
531                    setFeature(c.getFeatureMap(), "rel", 1, featureHash);
532                    c.setFeature("vsubcat", new StringRef("tr"));
533                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
534                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
535                    setFeature(c.getFeatureMap(), "whout", 6, featureHash);
536                    l.add(c);
537                    addRule(new Rule(l, true));
538                    
539                    // vbar(be:plus, rel:A, embv:B, copula:minus, whin:C, whout:D)=>verb(vsubcat:tr, be:plus, pl:E, exists:F, vform:G), [by], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D)
540                    l.clear();
541                    featureHash.clear();
542                    c = new Nonterminal("vbar");
543                    c.setFeature("be", new StringRef("plus"));
544                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
545                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
546                    c.setFeature("copula", new StringRef("minus"));
547                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
548                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
549                    l.add(c);
550                    c = new Nonterminal("verb");
551                    c.setFeature("vsubcat", new StringRef("tr"));
552                    c.setFeature("be", new StringRef("plus"));
553                    setFeature(c.getFeatureMap(), "pl", 4, featureHash);
554                    setFeature(c.getFeatureMap(), "exists", 5, featureHash);
555                    setFeature(c.getFeatureMap(), "vform", 6, featureHash);
556                    l.add(c);
557                    c = new Terminal("by");
558                    l.add(c);
559                    c = new Nonterminal("nounphrase_cut");
560                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
561                    c.setFeature("copula", new StringRef("minus"));
562                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
563                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
564                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
565                    l.add(c);
566                    addRule(new Rule(l, true));
567                    
568                    // vbar(be:plus, rel:A, embv:B, copula:plus, whin:C, whout:D)=>nounphrase_cut(of:plus, rel:A, pl:minus, copula:plus, embv:B, whin:C, whout:D)
569                    l.clear();
570                    featureHash.clear();
571                    c = new Nonterminal("vbar");
572                    c.setFeature("be", new StringRef("plus"));
573                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
574                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
575                    c.setFeature("copula", new StringRef("plus"));
576                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
577                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
578                    l.add(c);
579                    c = new Nonterminal("nounphrase_cut");
580                    c.setFeature("of", new StringRef("plus"));
581                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
582                    c.setFeature("pl", new StringRef("minus"));
583                    c.setFeature("copula", new StringRef("plus"));
584                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
585                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
586                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
587                    l.add(c);
588                    addRule(new Rule(l, true));
589                    
590                    // vbar(be:plus, rel:A, pl:minus, embv:B, copula:plus, whin:C, whout:D)=>nounphrase_cut(of:minus, rel:A, pl:minus, copula:plus, embv:B, whin:C, whout:D)
591                    l.clear();
592                    featureHash.clear();
593                    c = new Nonterminal("vbar");
594                    c.setFeature("be", new StringRef("plus"));
595                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
596                    c.setFeature("pl", new StringRef("minus"));
597                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
598                    c.setFeature("copula", new StringRef("plus"));
599                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
600                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
601                    l.add(c);
602                    c = new Nonterminal("nounphrase_cut");
603                    c.setFeature("of", new StringRef("minus"));
604                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
605                    c.setFeature("pl", new StringRef("minus"));
606                    c.setFeature("copula", new StringRef("plus"));
607                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
608                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
609                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
610                    l.add(c);
611                    addRule(new Rule(l, true));
612                    
613                    // vbar(be:plus, rel:A, copula:plus, whin:B, whout:B)=>adj_coord
614                    l.clear();
615                    featureHash.clear();
616                    c = new Nonterminal("vbar");
617                    c.setFeature("be", new StringRef("plus"));
618                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
619                    c.setFeature("copula", new StringRef("plus"));
620                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
621                    setFeature(c.getFeatureMap(), "whout", 1, featureHash);
622                    l.add(c);
623                    c = new Nonterminal("adj_coord");
624                    l.add(c);
625                    addRule(new Rule(l, true));
626                    
627                    // vbar(be:plus, rel:A, embv:B, copula:plus, whin:C, whout:D)=>compl_adj(rel:A, embv:B, whin:C, whout:D)
628                    l.clear();
629                    featureHash.clear();
630                    c = new Nonterminal("vbar");
631                    c.setFeature("be", new StringRef("plus"));
632                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
633                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
634                    c.setFeature("copula", new StringRef("plus"));
635                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
636                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
637                    l.add(c);
638                    c = new Nonterminal("compl_adj");
639                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
640                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
641                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
642                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
643                    l.add(c);
644                    addRule(new Rule(l, true));
645                    
646                    // nounphrase_cut(exist:plus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)=>nounphrase(exist:plus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)
647                    l.clear();
648                    featureHash.clear();
649                    c = new Nonterminal("nounphrase_cut");
650                    c.setFeature("exist", new StringRef("plus"));
651                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
652                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
653                    setFeature(c.getFeatureMap(), "def", 2, featureHash);
654                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
655                    setFeature(c.getFeatureMap(), "copula", 4, featureHash);
656                    setFeature(c.getFeatureMap(), "embv", 5, featureHash);
657                    setFeature(c.getFeatureMap(), "whin", 6, featureHash);
658                    setFeature(c.getFeatureMap(), "whout", 7, featureHash);
659                    l.add(c);
660                    c = new Nonterminal("nounphrase");
661                    c.setFeature("exist", new StringRef("plus"));
662                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
663                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
664                    setFeature(c.getFeatureMap(), "def", 2, featureHash);
665                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
666                    setFeature(c.getFeatureMap(), "copula", 4, featureHash);
667                    setFeature(c.getFeatureMap(), "embv", 5, featureHash);
668                    setFeature(c.getFeatureMap(), "whin", 6, featureHash);
669                    setFeature(c.getFeatureMap(), "whout", 7, featureHash);
670                    l.add(c);
671                    addRule(new Rule(l, true));
672                    
673                    // nounphrase_cut(exist:minus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)~>nounphrase(exist:minus, rel:A, of:B, def:C, pl:D, copula:E, embv:F, whin:G, whout:H)
674                    l.clear();
675                    featureHash.clear();
676                    c = new Nonterminal("nounphrase_cut");
677                    c.setFeature("exist", new StringRef("minus"));
678                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
679                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
680                    setFeature(c.getFeatureMap(), "def", 2, featureHash);
681                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
682                    setFeature(c.getFeatureMap(), "copula", 4, featureHash);
683                    setFeature(c.getFeatureMap(), "embv", 5, featureHash);
684                    setFeature(c.getFeatureMap(), "whin", 6, featureHash);
685                    setFeature(c.getFeatureMap(), "whout", 7, featureHash);
686                    l.add(c);
687                    c = new Nonterminal("nounphrase");
688                    c.setFeature("exist", new StringRef("minus"));
689                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
690                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
691                    setFeature(c.getFeatureMap(), "def", 2, featureHash);
692                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
693                    setFeature(c.getFeatureMap(), "copula", 4, featureHash);
694                    setFeature(c.getFeatureMap(), "embv", 5, featureHash);
695                    setFeature(c.getFeatureMap(), "whin", 6, featureHash);
696                    setFeature(c.getFeatureMap(), "whout", 7, featureHash);
697                    l.add(c);
698                    addRule(new Rule(l, false));
699                    
700                    // nounphrase(exist:plus, rel:A, of:minus, def:plus, pl:minus, embv:B, whin:C, whout:D)=>propername(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
701                    l.clear();
702                    featureHash.clear();
703                    c = new Nonterminal("nounphrase");
704                    c.setFeature("exist", new StringRef("plus"));
705                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
706                    c.setFeature("of", new StringRef("minus"));
707                    c.setFeature("def", new StringRef("plus"));
708                    c.setFeature("pl", new StringRef("minus"));
709                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
710                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
711                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
712                    l.add(c);
713                    c = new Nonterminal("propername");
714                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
715                    l.add(c);
716                    c = new Nonterminal("rel_phrase");
717                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
718                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
719                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
720                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
721                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
722                    l.add(c);
723                    addRule(new Rule(l, true));
724                    
725                    // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)=>var_ante
726                    l.clear();
727                    featureHash.clear();
728                    c = new Nonterminal("nounphrase");
729                    c.setFeature("exist", new StringRef("plus"));
730                    c.setFeature("of", new StringRef("minus"));
731                    c.setFeature("def", new StringRef("plus"));
732                    c.setFeature("pl", new StringRef("minus"));
733                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
734                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
735                    l.add(c);
736                    c = new Nonterminal("var_ante");
737                    l.add(c);
738                    addRule(new Rule(l, true));
739                    
740                    // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['DEF_NOUN_SG'(noun:B), 'REF'(text:C)], <<<(type:noun, hasvar:plus, noun:B, var:C)
741                    l.clear();
742                    featureHash.clear();
743                    c = new Nonterminal("nounphrase");
744                    c.setFeature("exist", new StringRef("plus"));
745                    c.setFeature("of", new StringRef("minus"));
746                    c.setFeature("def", new StringRef("plus"));
747                    c.setFeature("pl", new StringRef("minus"));
748                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
749                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
750                    l.add(c);
751                    c = new Terminal("DEF_NOUN_SG");
752                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
753                    l.add(c);
754                    c = new Terminal("REF");
755                    setFeature(c.getFeatureMap(), "text", 2, featureHash);
756                    l.add(c);
757                    c = new Nonterminal("<<<");
758                    c.setFeature("type", new StringRef("noun"));
759                    c.setFeature("hasvar", new StringRef("plus"));
760                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
761                    setFeature(c.getFeatureMap(), "var", 2, featureHash);
762                    l.add(c);
763                    addRule(new Rule(l, false));
764                    
765                    // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['DEF_NOUN_SG'(noun:B)], <<<(type:noun, noun:B)
766                    l.clear();
767                    featureHash.clear();
768                    c = new Nonterminal("nounphrase");
769                    c.setFeature("exist", new StringRef("plus"));
770                    c.setFeature("of", new StringRef("minus"));
771                    c.setFeature("def", new StringRef("plus"));
772                    c.setFeature("pl", new StringRef("minus"));
773                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
774                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
775                    l.add(c);
776                    c = new Terminal("DEF_NOUN_SG");
777                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
778                    l.add(c);
779                    c = new Nonterminal("<<<");
780                    c.setFeature("type", new StringRef("noun"));
781                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
782                    l.add(c);
783                    addRule(new Rule(l, false));
784                    
785                    // nounphrase(exist:plus, of:minus, def:plus, pl:minus, whin:A, whout:A)~>['REF'(text:B)], <<<(hasvar:plus, var:B)
786                    l.clear();
787                    featureHash.clear();
788                    c = new Nonterminal("nounphrase");
789                    c.setFeature("exist", new StringRef("plus"));
790                    c.setFeature("of", new StringRef("minus"));
791                    c.setFeature("def", new StringRef("plus"));
792                    c.setFeature("pl", new StringRef("minus"));
793                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
794                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
795                    l.add(c);
796                    c = new Terminal("REF");
797                    setFeature(c.getFeatureMap(), "text", 1, featureHash);
798                    l.add(c);
799                    c = new Nonterminal("<<<");
800                    c.setFeature("hasvar", new StringRef("plus"));
801                    setFeature(c.getFeatureMap(), "var", 1, featureHash);
802                    l.add(c);
803                    addRule(new Rule(l, false));
804                    
805                    // nounphrase(exist:plus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[a], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E)
806                    l.clear();
807                    featureHash.clear();
808                    c = new Nonterminal("nounphrase");
809                    c.setFeature("exist", new StringRef("plus"));
810                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
811                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
812                    c.setFeature("pl", new StringRef("minus"));
813                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
814                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
815                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
816                    l.add(c);
817                    c = new Terminal("a");
818                    l.add(c);
819                    c = new Nonterminal("noun_constr");
820                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
821                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
822                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
823                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
824                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
825                    l.add(c);
826                    addRule(new Rule(l, true));
827                    
828                    // nounphrase(exist:plus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[an], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E)
829                    l.clear();
830                    featureHash.clear();
831                    c = new Nonterminal("nounphrase");
832                    c.setFeature("exist", new StringRef("plus"));
833                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
834                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
835                    c.setFeature("pl", new StringRef("minus"));
836                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
837                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
838                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
839                    l.add(c);
840                    c = new Terminal("an");
841                    l.add(c);
842                    c = new Nonterminal("noun_constr");
843                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
844                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
845                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
846                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
847                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
848                    l.add(c);
849                    addRule(new Rule(l, true));
850                    
851                    // nounphrase(exist:plus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>exist_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
852                    l.clear();
853                    featureHash.clear();
854                    c = new Nonterminal("nounphrase");
855                    c.setFeature("exist", new StringRef("plus"));
856                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
857                    c.setFeature("of", new StringRef("minus"));
858                    c.setFeature("pl", new StringRef("minus"));
859                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
860                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
861                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
862                    l.add(c);
863                    c = new Nonterminal("exist_anon");
864                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
865                    l.add(c);
866                    c = new Nonterminal("var_ante");
867                    l.add(c);
868                    c = new Nonterminal("rel_phrase");
869                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
870                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
871                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
872                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
873                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
874                    l.add(c);
875                    addRule(new Rule(l, true));
876                    
877                    // nounphrase(exist:plus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>exist_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
878                    l.clear();
879                    featureHash.clear();
880                    c = new Nonterminal("nounphrase");
881                    c.setFeature("exist", new StringRef("plus"));
882                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
883                    c.setFeature("of", new StringRef("minus"));
884                    c.setFeature("pl", new StringRef("minus"));
885                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
886                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
887                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
888                    l.add(c);
889                    c = new Nonterminal("exist_anon");
890                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
891                    l.add(c);
892                    c = new Nonterminal("rel_phrase");
893                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
894                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
895                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
896                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
897                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
898                    l.add(c);
899                    addRule(new Rule(l, true));
900                    
901                    // nounphrase(exist:plus, of:minus, pl:plus, copula:minus, whin:A, whout:A)=>num_quant, ['NUM'], opt_adj_coord, ['NOUN_PL']
902                    l.clear();
903                    featureHash.clear();
904                    c = new Nonterminal("nounphrase");
905                    c.setFeature("exist", new StringRef("plus"));
906                    c.setFeature("of", new StringRef("minus"));
907                    c.setFeature("pl", new StringRef("plus"));
908                    c.setFeature("copula", new StringRef("minus"));
909                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
910                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
911                    l.add(c);
912                    c = new Nonterminal("num_quant");
913                    l.add(c);
914                    c = new Terminal("NUM");
915                    l.add(c);
916                    c = new Nonterminal("opt_adj_coord");
917                    l.add(c);
918                    c = new Terminal("NOUN_PL");
919                    l.add(c);
920                    addRule(new Rule(l, true));
921                    
922                    // nounphrase(exist:plus, of:minus, pl:minus, copula:minus, whin:A, whout:A)=>num_quant, [1], opt_adj_coord, ['NOUN_SG']
923                    l.clear();
924                    featureHash.clear();
925                    c = new Nonterminal("nounphrase");
926                    c.setFeature("exist", new StringRef("plus"));
927                    c.setFeature("of", new StringRef("minus"));
928                    c.setFeature("pl", new StringRef("minus"));
929                    c.setFeature("copula", new StringRef("minus"));
930                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
931                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
932                    l.add(c);
933                    c = new Nonterminal("num_quant");
934                    l.add(c);
935                    c = new Terminal("1");
936                    l.add(c);
937                    c = new Nonterminal("opt_adj_coord");
938                    l.add(c);
939                    c = new Terminal("NOUN_SG");
940                    l.add(c);
941                    addRule(new Rule(l, true));
942                    
943                    // nounphrase(exist:plus, of:minus, pl:minus, whout:plus)=>[what]
944                    l.clear();
945                    featureHash.clear();
946                    c = new Nonterminal("nounphrase");
947                    c.setFeature("exist", new StringRef("plus"));
948                    c.setFeature("of", new StringRef("minus"));
949                    c.setFeature("pl", new StringRef("minus"));
950                    c.setFeature("whout", new StringRef("plus"));
951                    l.add(c);
952                    c = new Terminal("what");
953                    l.add(c);
954                    addRule(new Rule(l, true));
955                    
956                    // nounphrase(exist:plus, of:minus, pl:minus, whout:plus)=>[who]
957                    l.clear();
958                    featureHash.clear();
959                    c = new Nonterminal("nounphrase");
960                    c.setFeature("exist", new StringRef("plus"));
961                    c.setFeature("of", new StringRef("minus"));
962                    c.setFeature("pl", new StringRef("minus"));
963                    c.setFeature("whout", new StringRef("plus"));
964                    l.add(c);
965                    c = new Terminal("who");
966                    l.add(c);
967                    addRule(new Rule(l, true));
968                    
969                    // nounphrase(exist:plus, rel:A, of:B, embv:C, pl:minus, whout:plus)=>[which], noun_constr(rel:A, of:B, embv:C, whin:plus, whout:plus)
970                    l.clear();
971                    featureHash.clear();
972                    c = new Nonterminal("nounphrase");
973                    c.setFeature("exist", new StringRef("plus"));
974                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
975                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
976                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
977                    c.setFeature("pl", new StringRef("minus"));
978                    c.setFeature("whout", new StringRef("plus"));
979                    l.add(c);
980                    c = new Terminal("which");
981                    l.add(c);
982                    c = new Nonterminal("noun_constr");
983                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
984                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
985                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
986                    c.setFeature("whin", new StringRef("plus"));
987                    c.setFeature("whout", new StringRef("plus"));
988                    l.add(c);
989                    addRule(new Rule(l, true));
990                    
991                    // nounphrase(exist:plus, of:minus, pl:plus, whout:plus)=>[which], opt_adj_coord, ['NOUN_PL']
992                    l.clear();
993                    featureHash.clear();
994                    c = new Nonterminal("nounphrase");
995                    c.setFeature("exist", new StringRef("plus"));
996                    c.setFeature("of", new StringRef("minus"));
997                    c.setFeature("pl", new StringRef("plus"));
998                    c.setFeature("whout", new StringRef("plus"));
999                    l.add(c);
1000                    c = new Terminal("which");
1001                    l.add(c);
1002                    c = new Nonterminal("opt_adj_coord");
1003                    l.add(c);
1004                    c = new Terminal("NOUN_PL");
1005                    l.add(c);
1006                    addRule(new Rule(l, true));
1007                    
1008                    // nounphrase(exist:minus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[every], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E)
1009                    l.clear();
1010                    featureHash.clear();
1011                    c = new Nonterminal("nounphrase");
1012                    c.setFeature("exist", new StringRef("minus"));
1013                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1014                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
1015                    c.setFeature("pl", new StringRef("minus"));
1016                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
1017                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1018                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1019                    l.add(c);
1020                    c = new Terminal("every");
1021                    l.add(c);
1022                    c = new Nonterminal("noun_constr");
1023                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1024                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
1025                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
1026                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1027                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1028                    l.add(c);
1029                    addRule(new Rule(l, true));
1030                    
1031                    // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>univ_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
1032                    l.clear();
1033                    featureHash.clear();
1034                    c = new Nonterminal("nounphrase");
1035                    c.setFeature("exist", new StringRef("minus"));
1036                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1037                    c.setFeature("of", new StringRef("minus"));
1038                    c.setFeature("pl", new StringRef("minus"));
1039                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1040                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1041                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1042                    l.add(c);
1043                    c = new Nonterminal("univ_anon");
1044                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1045                    l.add(c);
1046                    c = new Nonterminal("var_ante");
1047                    l.add(c);
1048                    c = new Nonterminal("rel_phrase");
1049                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1050                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1051                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1052                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1053                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1054                    l.add(c);
1055                    addRule(new Rule(l, true));
1056                    
1057                    // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>univ_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
1058                    l.clear();
1059                    featureHash.clear();
1060                    c = new Nonterminal("nounphrase");
1061                    c.setFeature("exist", new StringRef("minus"));
1062                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1063                    c.setFeature("of", new StringRef("minus"));
1064                    c.setFeature("pl", new StringRef("minus"));
1065                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1066                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1067                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1068                    l.add(c);
1069                    c = new Nonterminal("univ_anon");
1070                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1071                    l.add(c);
1072                    c = new Nonterminal("rel_phrase");
1073                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1074                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1075                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1076                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1077                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1078                    l.add(c);
1079                    addRule(new Rule(l, true));
1080                    
1081                    // nounphrase(exist:minus, rel:A, of:B, pl:minus, embv:C, whin:D, whout:E)=>[no], noun_constr(rel:A, of:B, embv:C, whin:D, whout:E)
1082                    l.clear();
1083                    featureHash.clear();
1084                    c = new Nonterminal("nounphrase");
1085                    c.setFeature("exist", new StringRef("minus"));
1086                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1087                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
1088                    c.setFeature("pl", new StringRef("minus"));
1089                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
1090                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1091                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1092                    l.add(c);
1093                    c = new Terminal("no");
1094                    l.add(c);
1095                    c = new Nonterminal("noun_constr");
1096                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1097                    setFeature(c.getFeatureMap(), "of", 1, featureHash);
1098                    setFeature(c.getFeatureMap(), "embv", 2, featureHash);
1099                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1100                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1101                    l.add(c);
1102                    addRule(new Rule(l, true));
1103                    
1104                    // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>neg_anon(human:E), var_ante, rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
1105                    l.clear();
1106                    featureHash.clear();
1107                    c = new Nonterminal("nounphrase");
1108                    c.setFeature("exist", new StringRef("minus"));
1109                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1110                    c.setFeature("of", new StringRef("minus"));
1111                    c.setFeature("pl", new StringRef("minus"));
1112                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1113                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1114                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1115                    l.add(c);
1116                    c = new Nonterminal("neg_anon");
1117                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1118                    l.add(c);
1119                    c = new Nonterminal("var_ante");
1120                    l.add(c);
1121                    c = new Nonterminal("rel_phrase");
1122                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1123                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1124                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1125                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1126                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1127                    l.add(c);
1128                    addRule(new Rule(l, true));
1129                    
1130                    // nounphrase(exist:minus, rel:A, of:minus, pl:minus, embv:B, whin:C, whout:D)=>neg_anon(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
1131                    l.clear();
1132                    featureHash.clear();
1133                    c = new Nonterminal("nounphrase");
1134                    c.setFeature("exist", new StringRef("minus"));
1135                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1136                    c.setFeature("of", new StringRef("minus"));
1137                    c.setFeature("pl", new StringRef("minus"));
1138                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1139                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1140                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1141                    l.add(c);
1142                    c = new Nonterminal("neg_anon");
1143                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1144                    l.add(c);
1145                    c = new Nonterminal("rel_phrase");
1146                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1147                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1148                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1149                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1150                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1151                    l.add(c);
1152                    addRule(new Rule(l, true));
1153                    
1154                    // noun_constr(rel:A, of:minus, embv:B, whin:C, whout:D)=>opt_adj_coord, noun_ante(human:E), rel_phrase(rel:A, embv:B, human:E, whin:C, whout:D)
1155                    l.clear();
1156                    featureHash.clear();
1157                    c = new Nonterminal("noun_constr");
1158                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1159                    c.setFeature("of", new StringRef("minus"));
1160                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1161                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1162                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1163                    l.add(c);
1164                    c = new Nonterminal("opt_adj_coord");
1165                    l.add(c);
1166                    c = new Nonterminal("noun_ante");
1167                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1168                    l.add(c);
1169                    c = new Nonterminal("rel_phrase");
1170                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1171                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1172                    setFeature(c.getFeatureMap(), "human", 4, featureHash);
1173                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1174                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1175                    l.add(c);
1176                    addRule(new Rule(l, true));
1177                    
1178                    // noun_constr(rel:A, of:plus, embv:B, whin:C, whout:D)=>opt_adj_coord, ['NOUN_SG', of], nounphrase_cut(rel:A, embv:B, whin:C, whout:D)
1179                    l.clear();
1180                    featureHash.clear();
1181                    c = new Nonterminal("noun_constr");
1182                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1183                    c.setFeature("of", new StringRef("plus"));
1184                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1185                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1186                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1187                    l.add(c);
1188                    c = new Nonterminal("opt_adj_coord");
1189                    l.add(c);
1190                    c = new Terminal("NOUN_SG");
1191                    l.add(c);
1192                    c = new Terminal("of");
1193                    l.add(c);
1194                    c = new Nonterminal("nounphrase_cut");
1195                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1196                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
1197                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1198                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1199                    l.add(c);
1200                    addRule(new Rule(l, true));
1201                    
1202                    // noun_ante(human:A)=>['NOUN_SG'(human:A, text:B, id:C)], newvar(var:D), >>>(type:noun, hasvar:plus, noun:B, var:D, id:C)
1203                    l.clear();
1204                    featureHash.clear();
1205                    c = new Nonterminal("noun_ante");
1206                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1207                    l.add(c);
1208                    c = new Terminal("NOUN_SG");
1209                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1210                    setFeature(c.getFeatureMap(), "text", 1, featureHash);
1211                    setFeature(c.getFeatureMap(), "id", 2, featureHash);
1212                    l.add(c);
1213                    c = new Nonterminal("newvar");
1214                    setFeature(c.getFeatureMap(), "var", 3, featureHash);
1215                    l.add(c);
1216                    c = new Nonterminal(">>>");
1217                    c.setFeature("type", new StringRef("noun"));
1218                    c.setFeature("hasvar", new StringRef("plus"));
1219                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
1220                    setFeature(c.getFeatureMap(), "var", 3, featureHash);
1221                    setFeature(c.getFeatureMap(), "id", 2, featureHash);
1222                    l.add(c);
1223                    addRule(new Rule(l, true));
1224                    
1225                    // noun_ante(human:A)=>['NOUN_SG'(human:A, text:B, id:C)], >>>(type:noun, hasvar:minus, noun:B, id:C)
1226                    l.clear();
1227                    featureHash.clear();
1228                    c = new Nonterminal("noun_ante");
1229                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1230                    l.add(c);
1231                    c = new Terminal("NOUN_SG");
1232                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1233                    setFeature(c.getFeatureMap(), "text", 1, featureHash);
1234                    setFeature(c.getFeatureMap(), "id", 2, featureHash);
1235                    l.add(c);
1236                    c = new Nonterminal(">>>");
1237                    c.setFeature("type", new StringRef("noun"));
1238                    c.setFeature("hasvar", new StringRef("minus"));
1239                    setFeature(c.getFeatureMap(), "noun", 1, featureHash);
1240                    setFeature(c.getFeatureMap(), "id", 2, featureHash);
1241                    l.add(c);
1242                    addRule(new Rule(l, true));
1243                    
1244                    // var_ante=>newvar(var:A, id:B), >>>(type:var, hasvar:plus, var:A, id:B)
1245                    l.clear();
1246                    featureHash.clear();
1247                    c = new Nonterminal("var_ante");
1248                    l.add(c);
1249                    c = new Nonterminal("newvar");
1250                    setFeature(c.getFeatureMap(), "var", 0, featureHash);
1251                    setFeature(c.getFeatureMap(), "id", 1, featureHash);
1252                    l.add(c);
1253                    c = new Nonterminal(">>>");
1254                    c.setFeature("type", new StringRef("var"));
1255                    c.setFeature("hasvar", new StringRef("plus"));
1256                    setFeature(c.getFeatureMap(), "var", 0, featureHash);
1257                    setFeature(c.getFeatureMap(), "id", 1, featureHash);
1258                    l.add(c);
1259                    addRule(new Rule(l, true));
1260                    
1261                    // newvar(var:A)=>['VAR'(text:A)], </<(hasvar:plus, var:A)
1262                    l.clear();
1263                    featureHash.clear();
1264                    c = new Nonterminal("newvar");
1265                    setFeature(c.getFeatureMap(), "var", 0, featureHash);
1266                    l.add(c);
1267                    c = new Terminal("VAR");
1268                    setFeature(c.getFeatureMap(), "text", 0, featureHash);
1269                    l.add(c);
1270                    c = new Nonterminal("</<");
1271                    c.setFeature("hasvar", new StringRef("plus"));
1272                    setFeature(c.getFeatureMap(), "var", 0, featureHash);
1273                    l.add(c);
1274                    addRule(new Rule(l, true));
1275                    
1276                    // auxiliary(be:minus, exists:minus, pl:minus)=>['has to']
1277                    l.clear();
1278                    featureHash.clear();
1279                    c = new Nonterminal("auxiliary");
1280                    c.setFeature("be", new StringRef("minus"));
1281                    c.setFeature("exists", new StringRef("minus"));
1282                    c.setFeature("pl", new StringRef("minus"));
1283                    l.add(c);
1284                    c = new Terminal("has to");
1285                    l.add(c);
1286                    addRule(new Rule(l, true));
1287                    
1288                    // auxiliary(be:minus, exists:minus, pl:plus)=>['have to']
1289                    l.clear();
1290                    featureHash.clear();
1291                    c = new Nonterminal("auxiliary");
1292                    c.setFeature("be", new StringRef("minus"));
1293                    c.setFeature("exists", new StringRef("minus"));
1294                    c.setFeature("pl", new StringRef("plus"));
1295                    l.add(c);
1296                    c = new Terminal("have to");
1297                    l.add(c);
1298                    addRule(new Rule(l, true));
1299                    
1300                    // auxiliary(be:plus, exists:plus, pl:minus)=>[is]
1301                    l.clear();
1302                    featureHash.clear();
1303                    c = new Nonterminal("auxiliary");
1304                    c.setFeature("be", new StringRef("plus"));
1305                    c.setFeature("exists", new StringRef("plus"));
1306                    c.setFeature("pl", new StringRef("minus"));
1307                    l.add(c);
1308                    c = new Terminal("is");
1309                    l.add(c);
1310                    addRule(new Rule(l, true));
1311                    
1312                    // auxiliary(be:plus, exists:minus, pl:minus)=>['is not']
1313                    l.clear();
1314                    featureHash.clear();
1315                    c = new Nonterminal("auxiliary");
1316                    c.setFeature("be", new StringRef("plus"));
1317                    c.setFeature("exists", new StringRef("minus"));
1318                    c.setFeature("pl", new StringRef("minus"));
1319                    l.add(c);
1320                    c = new Terminal("is not");
1321                    l.add(c);
1322                    addRule(new Rule(l, true));
1323                    
1324                    // auxiliary(be:plus, exists:minus, pl:minus)=>[is, not]
1325                    l.clear();
1326                    featureHash.clear();
1327                    c = new Nonterminal("auxiliary");
1328                    c.setFeature("be", new StringRef("plus"));
1329                    c.setFeature("exists", new StringRef("minus"));
1330                    c.setFeature("pl", new StringRef("minus"));
1331                    l.add(c);
1332                    c = new Terminal("is");
1333                    l.add(c);
1334                    c = new Terminal("not");
1335                    l.add(c);
1336                    addRule(new Rule(l, true));
1337                    
1338                    // auxiliary(be:plus, exists:plus, pl:plus)=>[are]
1339                    l.clear();
1340                    featureHash.clear();
1341                    c = new Nonterminal("auxiliary");
1342                    c.setFeature("be", new StringRef("plus"));
1343                    c.setFeature("exists", new StringRef("plus"));
1344                    c.setFeature("pl", new StringRef("plus"));
1345                    l.add(c);
1346                    c = new Terminal("are");
1347                    l.add(c);
1348                    addRule(new Rule(l, true));
1349                    
1350                    // auxiliary(be:plus, exists:minus, pl:plus)=>['are not']
1351                    l.clear();
1352                    featureHash.clear();
1353                    c = new Nonterminal("auxiliary");
1354                    c.setFeature("be", new StringRef("plus"));
1355                    c.setFeature("exists", new StringRef("minus"));
1356                    c.setFeature("pl", new StringRef("plus"));
1357                    l.add(c);
1358                    c = new Terminal("are not");
1359                    l.add(c);
1360                    addRule(new Rule(l, true));
1361                    
1362                    // auxiliary(be:plus, exists:minus, pl:plus)=>[are, not]
1363                    l.clear();
1364                    featureHash.clear();
1365                    c = new Nonterminal("auxiliary");
1366                    c.setFeature("be", new StringRef("plus"));
1367                    c.setFeature("exists", new StringRef("minus"));
1368                    c.setFeature("pl", new StringRef("plus"));
1369                    l.add(c);
1370                    c = new Terminal("are");
1371                    l.add(c);
1372                    c = new Terminal("not");
1373                    l.add(c);
1374                    addRule(new Rule(l, true));
1375                    
1376                    // auxiliary(be:minus, exists:minus, pl:minus)=>['does not']
1377                    l.clear();
1378                    featureHash.clear();
1379                    c = new Nonterminal("auxiliary");
1380                    c.setFeature("be", new StringRef("minus"));
1381                    c.setFeature("exists", new StringRef("minus"));
1382                    c.setFeature("pl", new StringRef("minus"));
1383                    l.add(c);
1384                    c = new Terminal("does not");
1385                    l.add(c);
1386                    addRule(new Rule(l, true));
1387                    
1388                    // auxiliary(be:minus, exists:minus, pl:plus)=>['do not']
1389                    l.clear();
1390                    featureHash.clear();
1391                    c = new Nonterminal("auxiliary");
1392                    c.setFeature("be", new StringRef("minus"));
1393                    c.setFeature("exists", new StringRef("minus"));
1394                    c.setFeature("pl", new StringRef("plus"));
1395                    l.add(c);
1396                    c = new Terminal("do not");
1397                    l.add(c);
1398                    addRule(new Rule(l, true));
1399                    
1400                    // auxiliary(be:minus, exists:minus)=>[can]
1401                    l.clear();
1402                    featureHash.clear();
1403                    c = new Nonterminal("auxiliary");
1404                    c.setFeature("be", new StringRef("minus"));
1405                    c.setFeature("exists", new StringRef("minus"));
1406                    l.add(c);
1407                    c = new Terminal("can");
1408                    l.add(c);
1409                    addRule(new Rule(l, true));
1410                    
1411                    // auxiliary(be:minus, exists:minus)=>[should]
1412                    l.clear();
1413                    featureHash.clear();
1414                    c = new Nonterminal("auxiliary");
1415                    c.setFeature("be", new StringRef("minus"));
1416                    c.setFeature("exists", new StringRef("minus"));
1417                    l.add(c);
1418                    c = new Terminal("should");
1419                    l.add(c);
1420                    addRule(new Rule(l, true));
1421                    
1422                    // auxiliary(be:minus, exists:minus)=>[must]
1423                    l.clear();
1424                    featureHash.clear();
1425                    c = new Nonterminal("auxiliary");
1426                    c.setFeature("be", new StringRef("minus"));
1427                    c.setFeature("exists", new StringRef("minus"));
1428                    l.add(c);
1429                    c = new Terminal("must");
1430                    l.add(c);
1431                    addRule(new Rule(l, true));
1432                    
1433                    // auxiliary(be:plus, exists:minus)=>[can, be]
1434                    l.clear();
1435                    featureHash.clear();
1436                    c = new Nonterminal("auxiliary");
1437                    c.setFeature("be", new StringRef("plus"));
1438                    c.setFeature("exists", new StringRef("minus"));
1439                    l.add(c);
1440                    c = new Terminal("can");
1441                    l.add(c);
1442                    c = new Terminal("be");
1443                    l.add(c);
1444                    addRule(new Rule(l, true));
1445                    
1446                    // auxiliary(be:plus, exists:minus)=>[should, be]
1447                    l.clear();
1448                    featureHash.clear();
1449                    c = new Nonterminal("auxiliary");
1450                    c.setFeature("be", new StringRef("plus"));
1451                    c.setFeature("exists", new StringRef("minus"));
1452                    l.add(c);
1453                    c = new Terminal("should");
1454                    l.add(c);
1455                    c = new Terminal("be");
1456                    l.add(c);
1457                    addRule(new Rule(l, true));
1458                    
1459                    // auxiliary(be:plus, exists:minus)=>[must, be]
1460                    l.clear();
1461                    featureHash.clear();
1462                    c = new Nonterminal("auxiliary");
1463                    c.setFeature("be", new StringRef("plus"));
1464                    c.setFeature("exists", new StringRef("minus"));
1465                    l.add(c);
1466                    c = new Terminal("must");
1467                    l.add(c);
1468                    c = new Terminal("be");
1469                    l.add(c);
1470                    addRule(new Rule(l, true));
1471                    
1472                    // auxiliary(be:plus, exists:minus, pl:minus)=>['has to', be]
1473                    l.clear();
1474                    featureHash.clear();
1475                    c = new Nonterminal("auxiliary");
1476                    c.setFeature("be", new StringRef("plus"));
1477                    c.setFeature("exists", new StringRef("minus"));
1478                    c.setFeature("pl", new StringRef("minus"));
1479                    l.add(c);
1480                    c = new Terminal("has to");
1481                    l.add(c);
1482                    c = new Terminal("be");
1483                    l.add(c);
1484                    addRule(new Rule(l, true));
1485                    
1486                    // auxiliary(be:plus, exists:minus, pl:plus)=>['have to', be]
1487                    l.clear();
1488                    featureHash.clear();
1489                    c = new Nonterminal("auxiliary");
1490                    c.setFeature("be", new StringRef("plus"));
1491                    c.setFeature("exists", new StringRef("minus"));
1492                    c.setFeature("pl", new StringRef("plus"));
1493                    l.add(c);
1494                    c = new Terminal("have to");
1495                    l.add(c);
1496                    c = new Terminal("be");
1497                    l.add(c);
1498                    addRule(new Rule(l, true));
1499                    
1500                    // auxiliary(be:plus, exists:minus)=>[cannot, be]
1501                    l.clear();
1502                    featureHash.clear();
1503                    c = new Nonterminal("auxiliary");
1504                    c.setFeature("be", new StringRef("plus"));
1505                    c.setFeature("exists", new StringRef("minus"));
1506                    l.add(c);
1507                    c = new Terminal("cannot");
1508                    l.add(c);
1509                    c = new Terminal("be");
1510                    l.add(c);
1511                    addRule(new Rule(l, true));
1512                    
1513                    // auxiliary(be:plus, exists:minus)=>[can, not, be]
1514                    l.clear();
1515                    featureHash.clear();
1516                    c = new Nonterminal("auxiliary");
1517                    c.setFeature("be", new StringRef("plus"));
1518                    c.setFeature("exists", new StringRef("minus"));
1519                    l.add(c);
1520                    c = new Terminal("can");
1521                    l.add(c);
1522                    c = new Terminal("not");
1523                    l.add(c);
1524                    c = new Terminal("be");
1525                    l.add(c);
1526                    addRule(new Rule(l, true));
1527                    
1528                    // auxiliary(be:plus, exists:minus)=>[should, not, be]
1529                    l.clear();
1530                    featureHash.clear();
1531                    c = new Nonterminal("auxiliary");
1532                    c.setFeature("be", new StringRef("plus"));
1533                    c.setFeature("exists", new StringRef("minus"));
1534                    l.add(c);
1535                    c = new Terminal("should");
1536                    l.add(c);
1537                    c = new Terminal("not");
1538                    l.add(c);
1539                    c = new Terminal("be");
1540                    l.add(c);
1541                    addRule(new Rule(l, true));
1542                    
1543                    // auxiliary(be:plus, exists:minus, pl:minus)=>['does not', 'have to', be]
1544                    l.clear();
1545                    featureHash.clear();
1546                    c = new Nonterminal("auxiliary");
1547                    c.setFeature("be", new StringRef("plus"));
1548                    c.setFeature("exists", new StringRef("minus"));
1549                    c.setFeature("pl", new StringRef("minus"));
1550                    l.add(c);
1551                    c = new Terminal("does not");
1552                    l.add(c);
1553                    c = new Terminal("have to");
1554                    l.add(c);
1555                    c = new Terminal("be");
1556                    l.add(c);
1557                    addRule(new Rule(l, true));
1558                    
1559                    // auxiliary(be:plus, exists:minus, pl:plus)=>['do not', 'have to', be]
1560                    l.clear();
1561                    featureHash.clear();
1562                    c = new Nonterminal("auxiliary");
1563                    c.setFeature("be", new StringRef("plus"));
1564                    c.setFeature("exists", new StringRef("minus"));
1565                    c.setFeature("pl", new StringRef("plus"));
1566                    l.add(c);
1567                    c = new Terminal("do not");
1568                    l.add(c);
1569                    c = new Terminal("have to");
1570                    l.add(c);
1571                    c = new Terminal("be");
1572                    l.add(c);
1573                    addRule(new Rule(l, true));
1574                    
1575                    // auxiliary(be:minus, exists:minus, pl:minus)=>[cannot]
1576                    l.clear();
1577                    featureHash.clear();
1578                    c = new Nonterminal("auxiliary");
1579                    c.setFeature("be", new StringRef("minus"));
1580                    c.setFeature("exists", new StringRef("minus"));
1581                    c.setFeature("pl", new StringRef("minus"));
1582                    l.add(c);
1583                    c = new Terminal("cannot");
1584                    l.add(c);
1585                    addRule(new Rule(l, true));
1586                    
1587                    // auxiliary(be:minus, exists:minus, pl:minus)=>[can, not]
1588                    l.clear();
1589                    featureHash.clear();
1590                    c = new Nonterminal("auxiliary");
1591                    c.setFeature("be", new StringRef("minus"));
1592                    c.setFeature("exists", new StringRef("minus"));
1593                    c.setFeature("pl", new StringRef("minus"));
1594                    l.add(c);
1595                    c = new Terminal("can");
1596                    l.add(c);
1597                    c = new Terminal("not");
1598                    l.add(c);
1599                    addRule(new Rule(l, true));
1600                    
1601                    // auxiliary(be:minus, exists:minus, pl:minus)=>[should, not]
1602                    l.clear();
1603                    featureHash.clear();
1604                    c = new Nonterminal("auxiliary");
1605                    c.setFeature("be", new StringRef("minus"));
1606                    c.setFeature("exists", new StringRef("minus"));
1607                    c.setFeature("pl", new StringRef("minus"));
1608                    l.add(c);
1609                    c = new Terminal("should");
1610                    l.add(c);
1611                    c = new Terminal("not");
1612                    l.add(c);
1613                    addRule(new Rule(l, true));
1614                    
1615                    // auxiliary(be:minus, exists:minus, pl:minus)=>['does not', 'have to']
1616                    l.clear();
1617                    featureHash.clear();
1618                    c = new Nonterminal("auxiliary");
1619                    c.setFeature("be", new StringRef("minus"));
1620                    c.setFeature("exists", new StringRef("minus"));
1621                    c.setFeature("pl", new StringRef("minus"));
1622                    l.add(c);
1623                    c = new Terminal("does not");
1624                    l.add(c);
1625                    c = new Terminal("have to");
1626                    l.add(c);
1627                    addRule(new Rule(l, true));
1628                    
1629                    // auxiliary(be:minus, exists:minus, pl:plus)=>['do not', 'have to']
1630                    l.clear();
1631                    featureHash.clear();
1632                    c = new Nonterminal("auxiliary");
1633                    c.setFeature("be", new StringRef("minus"));
1634                    c.setFeature("exists", new StringRef("minus"));
1635                    c.setFeature("pl", new StringRef("plus"));
1636                    l.add(c);
1637                    c = new Terminal("do not");
1638                    l.add(c);
1639                    c = new Terminal("have to");
1640                    l.add(c);
1641                    addRule(new Rule(l, true));
1642                    
1643                    // verb(be:minus, vsubcat:itr, pl:minus, vform:fin)=>['IV_FINSG']
1644                    l.clear();
1645                    featureHash.clear();
1646                    c = new Nonterminal("verb");
1647                    c.setFeature("be", new StringRef("minus"));
1648                    c.setFeature("vsubcat", new StringRef("itr"));
1649                    c.setFeature("pl", new StringRef("minus"));
1650                    c.setFeature("vform", new StringRef("fin"));
1651                    l.add(c);
1652                    c = new Terminal("IV_FINSG");
1653                    l.add(c);
1654                    addRule(new Rule(l, true));
1655                    
1656                    // verb(be:minus, vsubcat:itr, pl:plus, vform:fin)=>['IV_INFPL']
1657                    l.clear();
1658                    featureHash.clear();
1659                    c = new Nonterminal("verb");
1660                    c.setFeature("be", new StringRef("minus"));
1661                    c.setFeature("vsubcat", new StringRef("itr"));
1662                    c.setFeature("pl", new StringRef("plus"));
1663                    c.setFeature("vform", new StringRef("fin"));
1664                    l.add(c);
1665                    c = new Terminal("IV_INFPL");
1666                    l.add(c);
1667                    addRule(new Rule(l, true));
1668                    
1669                    // verb(be:minus, vsubcat:itr, vform:inf)=>['IV_INFPL']
1670                    l.clear();
1671                    featureHash.clear();
1672                    c = new Nonterminal("verb");
1673                    c.setFeature("be", new StringRef("minus"));
1674                    c.setFeature("vsubcat", new StringRef("itr"));
1675                    c.setFeature("vform", new StringRef("inf"));
1676                    l.add(c);
1677                    c = new Terminal("IV_INFPL");
1678                    l.add(c);
1679                    addRule(new Rule(l, true));
1680                    
1681                    // verb(be:minus, vsubcat:tr, pl:minus, vform:fin)=>['TV_FINSG']
1682                    l.clear();
1683                    featureHash.clear();
1684                    c = new Nonterminal("verb");
1685                    c.setFeature("be", new StringRef("minus"));
1686                    c.setFeature("vsubcat", new StringRef("tr"));
1687                    c.setFeature("pl", new StringRef("minus"));
1688                    c.setFeature("vform", new StringRef("fin"));
1689                    l.add(c);
1690                    c = new Terminal("TV_FINSG");
1691                    l.add(c);
1692                    addRule(new Rule(l, true));
1693                    
1694                    // verb(be:minus, vsubcat:tr, pl:plus, vform:fin)=>['TV_INFPL']
1695                    l.clear();
1696                    featureHash.clear();
1697                    c = new Nonterminal("verb");
1698                    c.setFeature("be", new StringRef("minus"));
1699                    c.setFeature("vsubcat", new StringRef("tr"));
1700                    c.setFeature("pl", new StringRef("plus"));
1701                    c.setFeature("vform", new StringRef("fin"));
1702                    l.add(c);
1703                    c = new Terminal("TV_INFPL");
1704                    l.add(c);
1705                    addRule(new Rule(l, true));
1706                    
1707                    // verb(be:minus, vsubcat:tr, vform:inf)=>['TV_INFPL']
1708                    l.clear();
1709                    featureHash.clear();
1710                    c = new Nonterminal("verb");
1711                    c.setFeature("be", new StringRef("minus"));
1712                    c.setFeature("vsubcat", new StringRef("tr"));
1713                    c.setFeature("vform", new StringRef("inf"));
1714                    l.add(c);
1715                    c = new Terminal("TV_INFPL");
1716                    l.add(c);
1717                    addRule(new Rule(l, true));
1718                    
1719                    // verb(be:plus, vsubcat:tr)=>['TV_PP']
1720                    l.clear();
1721                    featureHash.clear();
1722                    c = new Nonterminal("verb");
1723                    c.setFeature("be", new StringRef("plus"));
1724                    c.setFeature("vsubcat", new StringRef("tr"));
1725                    l.add(c);
1726                    c = new Terminal("TV_PP");
1727                    l.add(c);
1728                    addRule(new Rule(l, true));
1729                    
1730                    // rel_phrase(whin:A, whout:A)=>[]
1731                    l.clear();
1732                    featureHash.clear();
1733                    c = new Nonterminal("rel_phrase");
1734                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
1735                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
1736                    l.add(c);
1737                    addRule(new Rule(l, true));
1738                    
1739                    // rel_phrase(rel:plus, embv:plus, human:A, whin:B, whout:C)=>rel_pron(human:A, relpron:D), rel_phrase_1(human:A, relpron:D, whin:B, whout:C)
1740                    l.clear();
1741                    featureHash.clear();
1742                    c = new Nonterminal("rel_phrase");
1743                    c.setFeature("rel", new StringRef("plus"));
1744                    c.setFeature("embv", new StringRef("plus"));
1745                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1746                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1747                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1748                    l.add(c);
1749                    c = new Nonterminal("rel_pron");
1750                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1751                    setFeature(c.getFeatureMap(), "relpron", 3, featureHash);
1752                    l.add(c);
1753                    c = new Nonterminal("rel_phrase_1");
1754                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1755                    setFeature(c.getFeatureMap(), "relpron", 3, featureHash);
1756                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1757                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1758                    l.add(c);
1759                    addRule(new Rule(l, true));
1760                    
1761                    // rel_phrase_1(human:A, relpron:B, whin:C, whout:D)~>rel_phrase_2(human:A, rel:minus, relpron:B, whin:C, whout:E), or_rel_pron(human:A, relpron:B), rel_phrase_1(human:A, relpron:B, whin:E, whout:D)
1762                    l.clear();
1763                    featureHash.clear();
1764                    c = new Nonterminal("rel_phrase_1");
1765                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1766                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1767                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1768                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1769                    l.add(c);
1770                    c = new Nonterminal("rel_phrase_2");
1771                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1772                    c.setFeature("rel", new StringRef("minus"));
1773                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1774                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1775                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1776                    l.add(c);
1777                    c = new Nonterminal("or_rel_pron");
1778                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1779                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1780                    l.add(c);
1781                    c = new Nonterminal("rel_phrase_1");
1782                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1783                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1784                    setFeature(c.getFeatureMap(), "whin", 4, featureHash);
1785                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1786                    l.add(c);
1787                    addRule(new Rule(l, false));
1788                    
1789                    // rel_phrase_1(human:A, relpron:B, whin:C, whout:D)=>rel_phrase_2(human:A, relpron:B, whin:C, whout:D)
1790                    l.clear();
1791                    featureHash.clear();
1792                    c = new Nonterminal("rel_phrase_1");
1793                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1794                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1795                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1796                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1797                    l.add(c);
1798                    c = new Nonterminal("rel_phrase_2");
1799                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1800                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1801                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
1802                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
1803                    l.add(c);
1804                    addRule(new Rule(l, true));
1805                    
1806                    // rel_phrase_2(rel:A, relpron:B, human:C, whin:D, whout:E)=>vp_cut(rel:minus, pl:minus, whin:D, whout:F), and_rel_pron(human:C, relpron:B), rel_phrase_2(rel:A, relpron:B, human:C, whin:F, whout:E)
1807                    l.clear();
1808                    featureHash.clear();
1809                    c = new Nonterminal("rel_phrase_2");
1810                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1811                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1812                    setFeature(c.getFeatureMap(), "human", 2, featureHash);
1813                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1814                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1815                    l.add(c);
1816                    c = new Nonterminal("vp_cut");
1817                    c.setFeature("rel", new StringRef("minus"));
1818                    c.setFeature("pl", new StringRef("minus"));
1819                    setFeature(c.getFeatureMap(), "whin", 3, featureHash);
1820                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
1821                    l.add(c);
1822                    c = new Nonterminal("and_rel_pron");
1823                    setFeature(c.getFeatureMap(), "human", 2, featureHash);
1824                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1825                    l.add(c);
1826                    c = new Nonterminal("rel_phrase_2");
1827                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1828                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1829                    setFeature(c.getFeatureMap(), "human", 2, featureHash);
1830                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
1831                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
1832                    l.add(c);
1833                    addRule(new Rule(l, true));
1834                    
1835                    // rel_phrase_2(rel:A, whin:B, whout:C)=>vp_cut(rel:A, pl:minus, whin:B, whout:C)
1836                    l.clear();
1837                    featureHash.clear();
1838                    c = new Nonterminal("rel_phrase_2");
1839                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1840                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1841                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1842                    l.add(c);
1843                    c = new Nonterminal("vp_cut");
1844                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1845                    c.setFeature("pl", new StringRef("minus"));
1846                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1847                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1848                    l.add(c);
1849                    addRule(new Rule(l, true));
1850                    
1851                    // rel_phrase_2(rel:A, whin:B, whout:C)=>nounphrase_cut(rel:minus, copula:minus, pl:D, embv:E, whin:B, whout:F), auxiliary(be:minus, exists:G, pl:D), verb(vsubcat:tr, be:minus, exists:G, pl:D, vform:inf), v_modifiers(rel:A, embv:E, copula:minus, whin:F, whout:C)
1852                    l.clear();
1853                    featureHash.clear();
1854                    c = new Nonterminal("rel_phrase_2");
1855                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1856                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1857                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1858                    l.add(c);
1859                    c = new Nonterminal("nounphrase_cut");
1860                    c.setFeature("rel", new StringRef("minus"));
1861                    c.setFeature("copula", new StringRef("minus"));
1862                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
1863                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
1864                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1865                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
1866                    l.add(c);
1867                    c = new Nonterminal("auxiliary");
1868                    c.setFeature("be", new StringRef("minus"));
1869                    setFeature(c.getFeatureMap(), "exists", 6, featureHash);
1870                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
1871                    l.add(c);
1872                    c = new Nonterminal("verb");
1873                    c.setFeature("vsubcat", new StringRef("tr"));
1874                    c.setFeature("be", new StringRef("minus"));
1875                    setFeature(c.getFeatureMap(), "exists", 6, featureHash);
1876                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
1877                    c.setFeature("vform", new StringRef("inf"));
1878                    l.add(c);
1879                    c = new Nonterminal("v_modifiers");
1880                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1881                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
1882                    c.setFeature("copula", new StringRef("minus"));
1883                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
1884                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1885                    l.add(c);
1886                    addRule(new Rule(l, true));
1887                    
1888                    // rel_phrase_2(rel:A, whin:B, whout:C)=>nounphrase_cut(rel:minus, copula:minus, pl:D, embv:E, whin:B, whout:F), verb(vsubcat:tr, be:minus, exists:plus, pl:D, vform:fin), v_modifiers(rel:A, embv:E, copula:minus, whin:F, whout:C)
1889                    l.clear();
1890                    featureHash.clear();
1891                    c = new Nonterminal("rel_phrase_2");
1892                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1893                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1894                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1895                    l.add(c);
1896                    c = new Nonterminal("nounphrase_cut");
1897                    c.setFeature("rel", new StringRef("minus"));
1898                    c.setFeature("copula", new StringRef("minus"));
1899                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
1900                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
1901                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
1902                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
1903                    l.add(c);
1904                    c = new Nonterminal("verb");
1905                    c.setFeature("vsubcat", new StringRef("tr"));
1906                    c.setFeature("be", new StringRef("minus"));
1907                    c.setFeature("exists", new StringRef("plus"));
1908                    setFeature(c.getFeatureMap(), "pl", 3, featureHash);
1909                    c.setFeature("vform", new StringRef("fin"));
1910                    l.add(c);
1911                    c = new Nonterminal("v_modifiers");
1912                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
1913                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
1914                    c.setFeature("copula", new StringRef("minus"));
1915                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
1916                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
1917                    l.add(c);
1918                    addRule(new Rule(l, true));
1919                    
1920                    // rel_pron(relpron:that)=>[that]
1921                    l.clear();
1922                    featureHash.clear();
1923                    c = new Nonterminal("rel_pron");
1924                    c.setFeature("relpron", new StringRef("that"));
1925                    l.add(c);
1926                    c = new Terminal("that");
1927                    l.add(c);
1928                    addRule(new Rule(l, true));
1929                    
1930                    // rel_pron(human:plus, relpron:who)=>[who]
1931                    l.clear();
1932                    featureHash.clear();
1933                    c = new Nonterminal("rel_pron");
1934                    c.setFeature("human", new StringRef("plus"));
1935                    c.setFeature("relpron", new StringRef("who"));
1936                    l.add(c);
1937                    c = new Terminal("who");
1938                    l.add(c);
1939                    addRule(new Rule(l, true));
1940                    
1941                    // rel_pron(human:minus, relpron:which)=>[which]
1942                    l.clear();
1943                    featureHash.clear();
1944                    c = new Nonterminal("rel_pron");
1945                    c.setFeature("human", new StringRef("minus"));
1946                    c.setFeature("relpron", new StringRef("which"));
1947                    l.add(c);
1948                    c = new Terminal("which");
1949                    l.add(c);
1950                    addRule(new Rule(l, true));
1951                    
1952                    // or_rel_pron(human:A, relpron:B)=>[or], rel_pron(human:A, relpron:B)
1953                    l.clear();
1954                    featureHash.clear();
1955                    c = new Nonterminal("or_rel_pron");
1956                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1957                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1958                    l.add(c);
1959                    c = new Terminal("or");
1960                    l.add(c);
1961                    c = new Nonterminal("rel_pron");
1962                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
1963                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
1964                    l.add(c);
1965                    addRule(new Rule(l, true));
1966                    
1967                    // or_rel_pron(relpron:that)=>['or that']
1968                    l.clear();
1969                    featureHash.clear();
1970                    c = new Nonterminal("or_rel_pron");
1971                    c.setFeature("relpron", new StringRef("that"));
1972                    l.add(c);
1973                    c = new Terminal("or that");
1974                    l.add(c);
1975                    addRule(new Rule(l, true));
1976                    
1977                    // or_rel_pron(human:plus, relpron:who)=>['or who']
1978                    l.clear();
1979                    featureHash.clear();
1980                    c = new Nonterminal("or_rel_pron");
1981                    c.setFeature("human", new StringRef("plus"));
1982                    c.setFeature("relpron", new StringRef("who"));
1983                    l.add(c);
1984                    c = new Terminal("or who");
1985                    l.add(c);
1986                    addRule(new Rule(l, true));
1987                    
1988                    // or_rel_pron(human:minus, relpron:which)=>['or which']
1989                    l.clear();
1990                    featureHash.clear();
1991                    c = new Nonterminal("or_rel_pron");
1992                    c.setFeature("human", new StringRef("minus"));
1993                    c.setFeature("relpron", new StringRef("which"));
1994                    l.add(c);
1995                    c = new Terminal("or which");
1996                    l.add(c);
1997                    addRule(new Rule(l, true));
1998                    
1999                    // and_rel_pron(human:A, relpron:B)=>[and], rel_pron(human:A, relpron:B)
2000                    l.clear();
2001                    featureHash.clear();
2002                    c = new Nonterminal("and_rel_pron");
2003                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2004                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
2005                    l.add(c);
2006                    c = new Terminal("and");
2007                    l.add(c);
2008                    c = new Nonterminal("rel_pron");
2009                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2010                    setFeature(c.getFeatureMap(), "relpron", 1, featureHash);
2011                    l.add(c);
2012                    addRule(new Rule(l, true));
2013                    
2014                    // and_rel_pron(relpron:that)=>['and that']
2015                    l.clear();
2016                    featureHash.clear();
2017                    c = new Nonterminal("and_rel_pron");
2018                    c.setFeature("relpron", new StringRef("that"));
2019                    l.add(c);
2020                    c = new Terminal("and that");
2021                    l.add(c);
2022                    addRule(new Rule(l, true));
2023                    
2024                    // and_rel_pron(human:plus, relpron:who)=>['and who']
2025                    l.clear();
2026                    featureHash.clear();
2027                    c = new Nonterminal("and_rel_pron");
2028                    c.setFeature("human", new StringRef("plus"));
2029                    c.setFeature("relpron", new StringRef("who"));
2030                    l.add(c);
2031                    c = new Terminal("and who");
2032                    l.add(c);
2033                    addRule(new Rule(l, true));
2034                    
2035                    // and_rel_pron(human:minus, relpron:which)=>['and which']
2036                    l.clear();
2037                    featureHash.clear();
2038                    c = new Nonterminal("and_rel_pron");
2039                    c.setFeature("human", new StringRef("minus"));
2040                    c.setFeature("relpron", new StringRef("which"));
2041                    l.add(c);
2042                    c = new Terminal("and which");
2043                    l.add(c);
2044                    addRule(new Rule(l, true));
2045                    
2046                    // opt_adj_coord=>[]
2047                    l.clear();
2048                    featureHash.clear();
2049                    c = new Nonterminal("opt_adj_coord");
2050                    l.add(c);
2051                    addRule(new Rule(l, true));
2052                    
2053                    // opt_adj_coord=>adj_coord
2054                    l.clear();
2055                    featureHash.clear();
2056                    c = new Nonterminal("opt_adj_coord");
2057                    l.add(c);
2058                    c = new Nonterminal("adj_coord");
2059                    l.add(c);
2060                    addRule(new Rule(l, true));
2061                    
2062                    // adj_coord=>adj_itr
2063                    l.clear();
2064                    featureHash.clear();
2065                    c = new Nonterminal("adj_coord");
2066                    l.add(c);
2067                    c = new Nonterminal("adj_itr");
2068                    l.add(c);
2069                    addRule(new Rule(l, true));
2070                    
2071                    // adj_coord=>adj_itr, [and], adj_coord
2072                    l.clear();
2073                    featureHash.clear();
2074                    c = new Nonterminal("adj_coord");
2075                    l.add(c);
2076                    c = new Nonterminal("adj_itr");
2077                    l.add(c);
2078                    c = new Terminal("and");
2079                    l.add(c);
2080                    c = new Nonterminal("adj_coord");
2081                    l.add(c);
2082                    addRule(new Rule(l, true));
2083                    
2084                    // adj_itr=>['ADJ_ITR']
2085                    l.clear();
2086                    featureHash.clear();
2087                    c = new Nonterminal("adj_itr");
2088                    l.add(c);
2089                    c = new Terminal("ADJ_ITR");
2090                    l.add(c);
2091                    addRule(new Rule(l, true));
2092                    
2093                    // adj_itr=>[more, 'ADJ_ITR']
2094                    l.clear();
2095                    featureHash.clear();
2096                    c = new Nonterminal("adj_itr");
2097                    l.add(c);
2098                    c = new Terminal("more");
2099                    l.add(c);
2100                    c = new Terminal("ADJ_ITR");
2101                    l.add(c);
2102                    addRule(new Rule(l, true));
2103                    
2104                    // adj_itr=>['ADJ_ITR_COMP']
2105                    l.clear();
2106                    featureHash.clear();
2107                    c = new Nonterminal("adj_itr");
2108                    l.add(c);
2109                    c = new Terminal("ADJ_ITR_COMP");
2110                    l.add(c);
2111                    addRule(new Rule(l, true));
2112                    
2113                    // adj_itr=>[most, 'ADJ_ITR']
2114                    l.clear();
2115                    featureHash.clear();
2116                    c = new Nonterminal("adj_itr");
2117                    l.add(c);
2118                    c = new Terminal("most");
2119                    l.add(c);
2120                    c = new Terminal("ADJ_ITR");
2121                    l.add(c);
2122                    addRule(new Rule(l, true));
2123                    
2124                    // adj_itr=>['ADJ_ITR_SUP']
2125                    l.clear();
2126                    featureHash.clear();
2127                    c = new Nonterminal("adj_itr");
2128                    l.add(c);
2129                    c = new Terminal("ADJ_ITR_SUP");
2130                    l.add(c);
2131                    addRule(new Rule(l, true));
2132                    
2133                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_ITR', as], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D)
2134                    l.clear();
2135                    featureHash.clear();
2136                    c = new Nonterminal("compl_adj");
2137                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2138                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2139                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2140                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2141                    l.add(c);
2142                    c = new Terminal("as");
2143                    l.add(c);
2144                    c = new Terminal("ADJ_ITR");
2145                    l.add(c);
2146                    c = new Terminal("as");
2147                    l.add(c);
2148                    c = new Nonterminal("nounphrase_cut");
2149                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2150                    c.setFeature("copula", new StringRef("minus"));
2151                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2152                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2153                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2154                    l.add(c);
2155                    addRule(new Rule(l, true));
2156                    
2157                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_ITR_COMP', than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D)
2158                    l.clear();
2159                    featureHash.clear();
2160                    c = new Nonterminal("compl_adj");
2161                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2162                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2163                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2164                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2165                    l.add(c);
2166                    c = new Terminal("ADJ_ITR_COMP");
2167                    l.add(c);
2168                    c = new Terminal("than");
2169                    l.add(c);
2170                    c = new Nonterminal("nounphrase_cut");
2171                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2172                    c.setFeature("copula", new StringRef("minus"));
2173                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2174                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2175                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2176                    l.add(c);
2177                    addRule(new Rule(l, true));
2178                    
2179                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_ITR', than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D)
2180                    l.clear();
2181                    featureHash.clear();
2182                    c = new Nonterminal("compl_adj");
2183                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2184                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2185                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2186                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2187                    l.add(c);
2188                    c = new Terminal("more");
2189                    l.add(c);
2190                    c = new Terminal("ADJ_ITR");
2191                    l.add(c);
2192                    c = new Terminal("than");
2193                    l.add(c);
2194                    c = new Nonterminal("nounphrase_cut");
2195                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2196                    c.setFeature("copula", new StringRef("minus"));
2197                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2198                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2199                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2200                    l.add(c);
2201                    addRule(new Rule(l, true));
2202                    
2203                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:D)
2204                    l.clear();
2205                    featureHash.clear();
2206                    c = new Nonterminal("compl_adj");
2207                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2208                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2209                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2210                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2211                    l.add(c);
2212                    c = new Terminal("ADJ_TR");
2213                    l.add(c);
2214                    c = new Nonterminal("nounphrase_cut");
2215                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2216                    c.setFeature("copula", new StringRef("minus"));
2217                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2218                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2219                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2220                    l.add(c);
2221                    addRule(new Rule(l, true));
2222                    
2223                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:E)
2224                    l.clear();
2225                    featureHash.clear();
2226                    c = new Nonterminal("compl_adj");
2227                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2228                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2229                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2230                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2231                    l.add(c);
2232                    c = new Terminal("more");
2233                    l.add(c);
2234                    c = new Terminal("ADJ_TR");
2235                    l.add(c);
2236                    c = new Nonterminal("nounphrase_cut");
2237                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2238                    c.setFeature("copula", new StringRef("minus"));
2239                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2240                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2241                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
2242                    l.add(c);
2243                    addRule(new Rule(l, true));
2244                    
2245                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[most, 'ADJ_TR'], nounphrase_cut(rel:A, copula:minus, embv:B, whin:C, whout:E)
2246                    l.clear();
2247                    featureHash.clear();
2248                    c = new Nonterminal("compl_adj");
2249                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2250                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2251                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2252                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2253                    l.add(c);
2254                    c = new Terminal("most");
2255                    l.add(c);
2256                    c = new Terminal("ADJ_TR");
2257                    l.add(c);
2258                    c = new Nonterminal("nounphrase_cut");
2259                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2260                    c.setFeature("copula", new StringRef("minus"));
2261                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2262                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2263                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
2264                    l.add(c);
2265                    addRule(new Rule(l, true));
2266                    
2267                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_TR'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [as], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D)
2268                    l.clear();
2269                    featureHash.clear();
2270                    c = new Nonterminal("compl_adj");
2271                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2272                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2273                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2274                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2275                    l.add(c);
2276                    c = new Terminal("as");
2277                    l.add(c);
2278                    c = new Terminal("ADJ_TR");
2279                    l.add(c);
2280                    c = new Nonterminal("nounphrase_cut");
2281                    c.setFeature("rel", new StringRef("minus"));
2282                    c.setFeature("copula", new StringRef("minus"));
2283                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2284                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2285                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
2286                    l.add(c);
2287                    c = new Terminal("as");
2288                    l.add(c);
2289                    c = new Nonterminal("nounphrase_cut");
2290                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2291                    c.setFeature("copula", new StringRef("minus"));
2292                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2293                    setFeature(c.getFeatureMap(), "whin", 4, featureHash);
2294                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2295                    l.add(c);
2296                    addRule(new Rule(l, true));
2297                    
2298                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[as, 'ADJ_TR'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [as, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D)
2299                    l.clear();
2300                    featureHash.clear();
2301                    c = new Nonterminal("compl_adj");
2302                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2303                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2304                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2305                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2306                    l.add(c);
2307                    c = new Terminal("as");
2308                    l.add(c);
2309                    c = new Terminal("ADJ_TR");
2310                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2311                    l.add(c);
2312                    c = new Nonterminal("nounphrase_cut");
2313                    c.setFeature("rel", new StringRef("minus"));
2314                    c.setFeature("copula", new StringRef("minus"));
2315                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2316                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2317                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
2318                    l.add(c);
2319                    c = new Terminal("as");
2320                    l.add(c);
2321                    c = new Terminal("ADJ_TR_PREP");
2322                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2323                    l.add(c);
2324                    c = new Nonterminal("nounphrase_cut");
2325                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2326                    c.setFeature("copula", new StringRef("minus"));
2327                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2328                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
2329                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2330                    l.add(c);
2331                    addRule(new Rule(l, true));
2332                    
2333                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D)
2334                    l.clear();
2335                    featureHash.clear();
2336                    c = new Nonterminal("compl_adj");
2337                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2338                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2339                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2340                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2341                    l.add(c);
2342                    c = new Terminal("more");
2343                    l.add(c);
2344                    c = new Terminal("ADJ_TR");
2345                    l.add(c);
2346                    c = new Nonterminal("nounphrase_cut");
2347                    c.setFeature("rel", new StringRef("minus"));
2348                    c.setFeature("copula", new StringRef("minus"));
2349                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2350                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2351                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
2352                    l.add(c);
2353                    c = new Terminal("than");
2354                    l.add(c);
2355                    c = new Nonterminal("nounphrase_cut");
2356                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2357                    c.setFeature("copula", new StringRef("minus"));
2358                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2359                    setFeature(c.getFeatureMap(), "whin", 4, featureHash);
2360                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2361                    l.add(c);
2362                    addRule(new Rule(l, true));
2363                    
2364                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR_COMP'], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:E), [than], nounphrase_cut(rel:A, copula:minus, embv:B, whin:E, whout:D)
2365                    l.clear();
2366                    featureHash.clear();
2367                    c = new Nonterminal("compl_adj");
2368                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2369                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2370                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2371                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2372                    l.add(c);
2373                    c = new Terminal("ADJ_TR_COMP");
2374                    l.add(c);
2375                    c = new Nonterminal("nounphrase_cut");
2376                    c.setFeature("rel", new StringRef("minus"));
2377                    c.setFeature("copula", new StringRef("minus"));
2378                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2379                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2380                    setFeature(c.getFeatureMap(), "whout", 4, featureHash);
2381                    l.add(c);
2382                    c = new Terminal("than");
2383                    l.add(c);
2384                    c = new Nonterminal("nounphrase_cut");
2385                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2386                    c.setFeature("copula", new StringRef("minus"));
2387                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2388                    setFeature(c.getFeatureMap(), "whin", 4, featureHash);
2389                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2390                    l.add(c);
2391                    addRule(new Rule(l, true));
2392                    
2393                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>[more, 'ADJ_TR'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [than, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D)
2394                    l.clear();
2395                    featureHash.clear();
2396                    c = new Nonterminal("compl_adj");
2397                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2398                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2399                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2400                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2401                    l.add(c);
2402                    c = new Terminal("more");
2403                    l.add(c);
2404                    c = new Terminal("ADJ_TR");
2405                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2406                    l.add(c);
2407                    c = new Nonterminal("nounphrase_cut");
2408                    c.setFeature("rel", new StringRef("minus"));
2409                    c.setFeature("copula", new StringRef("minus"));
2410                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2411                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2412                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
2413                    l.add(c);
2414                    c = new Terminal("than");
2415                    l.add(c);
2416                    c = new Terminal("ADJ_TR_PREP");
2417                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2418                    l.add(c);
2419                    c = new Nonterminal("nounphrase_cut");
2420                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2421                    c.setFeature("copula", new StringRef("minus"));
2422                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2423                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
2424                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2425                    l.add(c);
2426                    addRule(new Rule(l, true));
2427                    
2428                    // compl_adj(rel:A, embv:B, whin:C, whout:D)=>['ADJ_TR_COMP'(prep:E)], nounphrase_cut(rel:minus, copula:minus, embv:B, whin:C, whout:F), [than, 'ADJ_TR_PREP'(prep:E)], nounphrase_cut(rel:A, copula:minus, embv:B, whin:F, whout:D)
2429                    l.clear();
2430                    featureHash.clear();
2431                    c = new Nonterminal("compl_adj");
2432                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2433                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2434                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2435                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2436                    l.add(c);
2437                    c = new Terminal("ADJ_TR_COMP");
2438                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2439                    l.add(c);
2440                    c = new Nonterminal("nounphrase_cut");
2441                    c.setFeature("rel", new StringRef("minus"));
2442                    c.setFeature("copula", new StringRef("minus"));
2443                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2444                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2445                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
2446                    l.add(c);
2447                    c = new Terminal("than");
2448                    l.add(c);
2449                    c = new Terminal("ADJ_TR_PREP");
2450                    setFeature(c.getFeatureMap(), "prep", 4, featureHash);
2451                    l.add(c);
2452                    c = new Nonterminal("nounphrase_cut");
2453                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2454                    c.setFeature("copula", new StringRef("minus"));
2455                    setFeature(c.getFeatureMap(), "embv", 1, featureHash);
2456                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
2457                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2458                    l.add(c);
2459                    addRule(new Rule(l, true));
2460                    
2461                    // v_modifiers(whin:A, whout:A)=>[]
2462                    l.clear();
2463                    featureHash.clear();
2464                    c = new Nonterminal("v_modifiers");
2465                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
2466                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
2467                    l.add(c);
2468                    addRule(new Rule(l, true));
2469                    
2470                    // v_modifiers(rel:A, embv:minus, copula:B, whin:C, whout:D)=>adv_coord(copula:B), v_modifiers_x(rel:A, copula:B, whin:C, whout:D)
2471                    l.clear();
2472                    featureHash.clear();
2473                    c = new Nonterminal("v_modifiers");
2474                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2475                    c.setFeature("embv", new StringRef("minus"));
2476                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2477                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2478                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2479                    l.add(c);
2480                    c = new Nonterminal("adv_coord");
2481                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2482                    l.add(c);
2483                    c = new Nonterminal("v_modifiers_x");
2484                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2485                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2486                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2487                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2488                    l.add(c);
2489                    addRule(new Rule(l, true));
2490                    
2491                    // v_modifiers(rel:A, embv:minus, copula:B, whin:C, whout:D)=>pp(rel:A, embv:E, whin:C, whout:F), v_modifiers(rel:A, embv:E, copula:B, whin:F, whout:D)
2492                    l.clear();
2493                    featureHash.clear();
2494                    c = new Nonterminal("v_modifiers");
2495                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2496                    c.setFeature("embv", new StringRef("minus"));
2497                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2498                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2499                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2500                    l.add(c);
2501                    c = new Nonterminal("pp");
2502                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2503                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
2504                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2505                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
2506                    l.add(c);
2507                    c = new Nonterminal("v_modifiers");
2508                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2509                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
2510                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2511                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
2512                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2513                    l.add(c);
2514                    addRule(new Rule(l, true));
2515                    
2516                    // v_modifiers_x(whin:A, whout:A)=>[]
2517                    l.clear();
2518                    featureHash.clear();
2519                    c = new Nonterminal("v_modifiers_x");
2520                    setFeature(c.getFeatureMap(), "whin", 0, featureHash);
2521                    setFeature(c.getFeatureMap(), "whout", 0, featureHash);
2522                    l.add(c);
2523                    addRule(new Rule(l, true));
2524                    
2525                    // v_modifiers_x(rel:A, copula:B, whin:C, whout:D)=>pp(rel:A, embv:E, whin:C, whout:F), v_modifiers(rel:A, embv:E, copula:B, whin:F, whout:D)
2526                    l.clear();
2527                    featureHash.clear();
2528                    c = new Nonterminal("v_modifiers_x");
2529                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2530                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2531                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2532                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2533                    l.add(c);
2534                    c = new Nonterminal("pp");
2535                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2536                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
2537                    setFeature(c.getFeatureMap(), "whin", 2, featureHash);
2538                    setFeature(c.getFeatureMap(), "whout", 5, featureHash);
2539                    l.add(c);
2540                    c = new Nonterminal("v_modifiers");
2541                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2542                    setFeature(c.getFeatureMap(), "embv", 4, featureHash);
2543                    setFeature(c.getFeatureMap(), "copula", 1, featureHash);
2544                    setFeature(c.getFeatureMap(), "whin", 5, featureHash);
2545                    setFeature(c.getFeatureMap(), "whout", 3, featureHash);
2546                    l.add(c);
2547                    addRule(new Rule(l, true));
2548                    
2549                    // pp(rel:A, whin:B, whout:C)=>['PREP'], nounphrase_cut(rel:A, whin:B, whout:C)
2550                    l.clear();
2551                    featureHash.clear();
2552                    c = new Nonterminal("pp");
2553                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2554                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
2555                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
2556                    l.add(c);
2557                    c = new Terminal("PREP");
2558                    l.add(c);
2559                    c = new Nonterminal("nounphrase_cut");
2560                    setFeature(c.getFeatureMap(), "rel", 0, featureHash);
2561                    setFeature(c.getFeatureMap(), "whin", 1, featureHash);
2562                    setFeature(c.getFeatureMap(), "whout", 2, featureHash);
2563                    l.add(c);
2564                    addRule(new Rule(l, true));
2565                    
2566                    // adv_coord(copula:minus)=>adv
2567                    l.clear();
2568                    featureHash.clear();
2569                    c = new Nonterminal("adv_coord");
2570                    c.setFeature("copula", new StringRef("minus"));
2571                    l.add(c);
2572                    c = new Nonterminal("adv");
2573                    l.add(c);
2574                    addRule(new Rule(l, true));
2575                    
2576                    // adv_coord(copula:minus)=>adv, [and], adv_coord
2577                    l.clear();
2578                    featureHash.clear();
2579                    c = new Nonterminal("adv_coord");
2580                    c.setFeature("copula", new StringRef("minus"));
2581                    l.add(c);
2582                    c = new Nonterminal("adv");
2583                    l.add(c);
2584                    c = new Terminal("and");
2585                    l.add(c);
2586                    c = new Nonterminal("adv_coord");
2587                    l.add(c);
2588                    addRule(new Rule(l, true));
2589                    
2590                    // adv=>['ADV']
2591                    l.clear();
2592                    featureHash.clear();
2593                    c = new Nonterminal("adv");
2594                    l.add(c);
2595                    c = new Terminal("ADV");
2596                    l.add(c);
2597                    addRule(new Rule(l, true));
2598                    
2599                    // adv=>[more, 'ADV']
2600                    l.clear();
2601                    featureHash.clear();
2602                    c = new Nonterminal("adv");
2603                    l.add(c);
2604                    c = new Terminal("more");
2605                    l.add(c);
2606                    c = new Terminal("ADV");
2607                    l.add(c);
2608                    addRule(new Rule(l, true));
2609                    
2610                    // adv=>['ADV_COMP']
2611                    l.clear();
2612                    featureHash.clear();
2613                    c = new Nonterminal("adv");
2614                    l.add(c);
2615                    c = new Terminal("ADV_COMP");
2616                    l.add(c);
2617                    addRule(new Rule(l, true));
2618                    
2619                    // adv=>[most, 'ADV']
2620                    l.clear();
2621                    featureHash.clear();
2622                    c = new Nonterminal("adv");
2623                    l.add(c);
2624                    c = new Terminal("most");
2625                    l.add(c);
2626                    c = new Terminal("ADV");
2627                    l.add(c);
2628                    addRule(new Rule(l, true));
2629                    
2630                    // adv=>['ADV_SUP']
2631                    l.clear();
2632                    featureHash.clear();
2633                    c = new Nonterminal("adv");
2634                    l.add(c);
2635                    c = new Terminal("ADV_SUP");
2636                    l.add(c);
2637                    addRule(new Rule(l, true));
2638                    
2639                    // exist_anon(human:minus)=>[something]
2640                    l.clear();
2641                    featureHash.clear();
2642                    c = new Nonterminal("exist_anon");
2643                    c.setFeature("human", new StringRef("minus"));
2644                    l.add(c);
2645                    c = new Terminal("something");
2646                    l.add(c);
2647                    addRule(new Rule(l, true));
2648                    
2649                    // exist_anon(human:plus)=>[somebody]
2650                    l.clear();
2651                    featureHash.clear();
2652                    c = new Nonterminal("exist_anon");
2653                    c.setFeature("human", new StringRef("plus"));
2654                    l.add(c);
2655                    c = new Terminal("somebody");
2656                    l.add(c);
2657                    addRule(new Rule(l, true));
2658                    
2659                    // univ_anon(human:minus)=>[everything]
2660                    l.clear();
2661                    featureHash.clear();
2662                    c = new Nonterminal("univ_anon");
2663                    c.setFeature("human", new StringRef("minus"));
2664                    l.add(c);
2665                    c = new Terminal("everything");
2666                    l.add(c);
2667                    addRule(new Rule(l, true));
2668                    
2669                    // univ_anon(human:plus)=>[everybody]
2670                    l.clear();
2671                    featureHash.clear();
2672                    c = new Nonterminal("univ_anon");
2673                    c.setFeature("human", new StringRef("plus"));
2674                    l.add(c);
2675                    c = new Terminal("everybody");
2676                    l.add(c);
2677                    addRule(new Rule(l, true));
2678                    
2679                    // neg_anon(human:minus)=>[nothing]
2680                    l.clear();
2681                    featureHash.clear();
2682                    c = new Nonterminal("neg_anon");
2683                    c.setFeature("human", new StringRef("minus"));
2684                    l.add(c);
2685                    c = new Terminal("nothing");
2686                    l.add(c);
2687                    addRule(new Rule(l, true));
2688                    
2689                    // neg_anon(human:plus)=>[nobody]
2690                    l.clear();
2691                    featureHash.clear();
2692                    c = new Nonterminal("neg_anon");
2693                    c.setFeature("human", new StringRef("plus"));
2694                    l.add(c);
2695                    c = new Terminal("nobody");
2696                    l.add(c);
2697                    addRule(new Rule(l, true));
2698                    
2699                    // num_quant=>['at least']
2700                    l.clear();
2701                    featureHash.clear();
2702                    c = new Nonterminal("num_quant");
2703                    l.add(c);
2704                    c = new Terminal("at least");
2705                    l.add(c);
2706                    addRule(new Rule(l, true));
2707                    
2708                    // num_quant=>['at most']
2709                    l.clear();
2710                    featureHash.clear();
2711                    c = new Nonterminal("num_quant");
2712                    l.add(c);
2713                    c = new Terminal("at most");
2714                    l.add(c);
2715                    addRule(new Rule(l, true));
2716                    
2717                    // num_quant=>['less than']
2718                    l.clear();
2719                    featureHash.clear();
2720                    c = new Nonterminal("num_quant");
2721                    l.add(c);
2722                    c = new Terminal("less than");
2723                    l.add(c);
2724                    addRule(new Rule(l, true));
2725                    
2726                    // num_quant=>['more than']
2727                    l.clear();
2728                    featureHash.clear();
2729                    c = new Nonterminal("num_quant");
2730                    l.add(c);
2731                    c = new Terminal("more than");
2732                    l.add(c);
2733                    addRule(new Rule(l, true));
2734                    
2735                    // num_quant=>[exactly]
2736                    l.clear();
2737                    featureHash.clear();
2738                    c = new Nonterminal("num_quant");
2739                    l.add(c);
2740                    c = new Terminal("exactly");
2741                    l.add(c);
2742                    addRule(new Rule(l, true));
2743                    
2744                    // propername(human:A)=>['PN_SG'(human:A)]
2745                    l.clear();
2746                    featureHash.clear();
2747                    c = new Nonterminal("propername");
2748                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2749                    l.add(c);
2750                    c = new Terminal("PN_SG");
2751                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2752                    l.add(c);
2753                    addRule(new Rule(l, true));
2754                    
2755                    // propername(human:A)=>['PNDEF_SG'(human:A)]
2756                    l.clear();
2757                    featureHash.clear();
2758                    c = new Nonterminal("propername");
2759                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2760                    l.add(c);
2761                    c = new Terminal("PNDEF_SG");
2762                    setFeature(c.getFeatureMap(), "human", 0, featureHash);
2763                    l.add(c);
2764                    addRule(new Rule(l, true));
2765    
2766            }
2767            
2768            private void setFeature(FeatureMap fm, String featureName, int varID, HashMap<Integer, StringRef> featureHash) {
2769                    if (featureHash.get(varID) == null) {
2770                            StringRef stringRef = new StringRef();
2771                            fm.setFeature(featureName, stringRef);
2772                            featureHash.put(varID, stringRef);
2773                    } else {
2774                            fm.setFeature(featureName, featureHash.get(varID));
2775                    }
2776            }
2777            
2778    }