ep-chunks.soar

sp {chunk*apply*finish-comprehend*t2005-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling locations)}
    (<w1> ^spelling locations)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling |.|)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type CN)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @W23 +
           ^not-merged-receiver <i2> +)
    (@W23 ^delay-retry true + ^structure-type T + ^spelling |.| +)
    (<i2> ^semantics <s3> + ^lt @W23 + ^current-word <w2> +
           ^structure-type T +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1992-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling matched)}
    (<w1> ^spelling matched)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling locations)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type CN)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @L13 +
           ^not-merged-receiver <i2> +)
    (@L13 ^syntactic-referent-type DP + ^referent @P7005 + ^structure-type N +
           ^spelling locations + ^number plural +)
    (@P7005 ^multiple true + ^property @P7000 + ^handle location +)
    (@P7000 ^item-type property + ^handle category + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @L13 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle location + ^property @P7000 + ^multiple true +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1979-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling eight)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling matched)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type CN ^spelling eight)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @M3 +
           ^not-merged-receiver <i2> +)
    (@M3 ^attachment immediate + ^referent @M4 + ^structure-type ADJ +
           ^spelling matched +)
    (@M4 ^property @C38 + ^handle matched +)
    (@C38 ^handle property + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @M3 + ^current-word <w2> +
           ^structure-type ADJ + ^lt-referent <n2> +)
    (<n2> ^handle matched + ^property @C38 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1967-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling are)}
    (<w1> ^spelling are)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling eight)
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @E29 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +)
    (@E29 ^constraint @P11208 + ^super-type @T10000 + ^spelling eight +
           ^number singular +)
    (<n2> ^structure-type N + ^parent-receiver <i2> + ^lt @C82 +
           ^current-word <w2> +)
    (<n3> ^structure-type PP + ^parent-receiver <i2> + ^lt @C83 +
           ^current-word <w2> +)
    (<i2> ^semantics <s5> + ^proto-lt <p1> + ^super-type @T10000 +
           ^current-word <w2> + ^lt <p1> + ^constraint @P11208 +
           ^structure-type CN +)
    (@T10000 ^specifier indefinite + ^converts-to DP + ^assigners @C83 +
           ^assigners @C82 + ^assigners @C81 + ^structure-type CN +)
    (<p1> ^spelling eight + ^number singular + ^constraint @P11208 +
           ^copied yes + ^structure-type CN + ^assigners @C83 +
           ^assigners @C82 + ^assigners @C81 + ^converts-to DP +
           ^specifier indefinite +)
    (@P11208 ^property @P11000 + ^item-type predicate + ^handle 8 +)
    (@P11000 ^item-type property + ^handle number + ^type number +)
    (@C81 ^repeatable true + ^optional true + ^relative-position after +
           ^before @C82 + ^syntactic-structure adjoin + ^structure-type ADJ +)
    (@C82 ^optional true + ^relative-position after + ^before @C83 +
           ^syntactic-structure head + ^structure-type N +)
    (@C83 ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^structure-type PP +)
    (<n4> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @C81 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t1951-1
    :chunk
    (state <s2> ^operator <o1> ^segment <s1>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i2> ^structure-type IS-V ^structure-type <c6>)
    (<i1> ^lt <t1> ^structure-type <c5> ^structure-type <c3>
          ^structure-type <c2> ^current-word <w1> ^lt <t2>)
    (<t1> ^spelling there)
    (<s1> ^not-merged-receiver <i1> ^retrieved-stack <n2>)
    (<n2> ^prior <n1>)
    (<n1> ^item <i1>)
    (<t2> ^spelling <c4>)
    (<w1> ^spelling <c1>)
    -->
    (<s1> ^comprehension-structure <c7> + ^construction-comprehended <c8> +)
    (<c7> ^processed true + ^type construction + ^words prior-word +
           ^successful-query <x1> + ^retrieved-lexical-item @S81 +
           ^not-merged-receiver <i3> + ^not-merged-assigner <n3> +
           ^not-merged-assigner <n4> + ^not-merged-assigner <n5> +
           ^not-merged-assigner <n6> + ^not-merged-assigner <n7> +
           ^remove-receiver <i1> +)
    (<x1> ^prior-word-first false + ^prior-word there + ^current-word IS-V +)
    (<n3> ^structure-type PP + ^parent-receiver <i3> + ^lt @I104 +
           ^current-word @S81 +)
    (<n4> ^structure-type IS-V + ^parent-receiver <i3> + ^lt @I103 +
           ^current-word @S81 +)
    (<n5> ^structure-type DP + ^parent-receiver <i3> + ^lt @I107 +
           ^current-word @S81 +)
    (<n6> ^structure-type ADV + ^parent-receiver <i3> + ^lt @I105 +
           ^current-word @S81 +)
    (<i3> ^lt @S81 + ^current-word @S81 + ^structure-type C +)
    (@S81 ^processed true + ^converts-to CP +
           ^message-type object-description + ^assigners @I107 +
           ^assigners @I106 + ^assigners @I105 + ^assigners @I104 +
           ^assigners @I103 + ^prior-word-first false +
           ^construction There-is-ADJ/DP/PP + ^prior-word there +
           ^current-word IS-V + ^structure-type C +)
    (@I103 ^before @I107 + ^before @I106 + ^before @I105 + ^before @I104 +
           ^syntactic-structure predicate + ^required true +
           ^structure-type IS-V +)
    (@I105 ^referent-type literal + ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@I104 ^exclusive @I107 + ^exclusive @I106 + ^optional true +
           ^syntactic-structure complement + ^semantic-structure arg2 +
           ^structure-type PP +)
    (@I106 ^referent-type literal + ^exclusive @I107 + ^exclusive @I104 +
           ^optional true + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type ADJ +)
    (@I107 ^exclusive @I106 + ^exclusive @I104 + ^optional true +
           ^syntactic-structure predicate + ^semantic-structure predicate +
           ^structure-type DP +)
    (<n7> ^structure-type ADJ + ^parent-receiver <i3> + ^lt @I106 +
           ^current-word @S81 +)
    (<c8> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t1936-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling there)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling are)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <t1> ^lt <t3> ^lt <t2>)
    (<t1> ^structure-type DPX)
    (<t3> ^structure-type DPX)
    (<t2> ^spelling there)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10053 +
           ^not-merged-receiver <i2> +)
    (@A10053 ^tense present + ^structure-type IS-V + ^spelling are +
           ^number plural +)
    (<i2> ^semantics <s3> + ^lt @A10053 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete2*onc*t1924-1
    :chunk
    (state <s3> ^operator <o1> ^segment <s4>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type C ^current-word <s1> ^current-word <s2>)
    (<i2> ^structure-type DPX)
    (<s1> ^first-word true)
    (<s2> ^first-word true)
    -->
    (<s4> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete*onc*t1919-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*1>)
      (<c*1> ^first-word true)}
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type RPN)
    (<i2> ^structure-type DPX)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*finish-comprehend*t1912-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling that)}
    (<w1> ^spelling that)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling there)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <t1> ^lt <t4> ^lt <t3> ^lt <t2>)
    (<t1> ^spelling is-that)
    (<t4> ^structure-type RPN)
    (<t3> ^structure-type RPN)
    (<t2> ^spelling is-that)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1018 +
           ^not-merged-receiver <i2> +)
    (@T1018 ^referent @R10062 + ^structure-type DPX + ^spelling there +
           ^number singular +)
    (@R10062 ^property @P90107 + ^handle there +)
    (@P90107 ^handle handle + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @T1018 + ^current-word <w2> +
           ^structure-type DPX + ^lt-referent <n2> +)
    (<n2> ^handle there + ^property @P90107 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1898-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<s1> ^prior-word <w1>)
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> ^spelling that)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T9033 +
           ^not-merged-receiver <i1> + ^not-merged-assigner <n1> +)
    (<i1> ^semantics <s3> + ^lt @T9033 + ^current-word <w2> +
           ^structure-type RPN +)
    (@T9033 ^consumes-prior-word false + ^converts-to RC + ^assigners @I21 +
           ^prior-word is + ^current-word that + ^attachment immediate +
           ^structure-type RPN + ^spelling is-that +)
    (@I21 ^delay-merge true + ^relative-position after +
           ^syntactic-structure head + ^semantic-structure *copy* +
           ^required true + ^structure-type CP +)
    (<n1> ^structure-type CP + ^parent-receiver <i1> + ^lt @I21 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1883-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
   -{ (<s2> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling goal)}
    (<w1> ^spelling goal)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling is)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (@I8 ^tense present + ^structure-type IS-V + ^spelling is +
           ^number singular +)
    (<i2> ^semantics <s4> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1870-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling goal)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @G10006 +
           ^not-merged-receiver <i2> +)
    (@G10006 ^syntactic-referent-type DP + ^object-feature handle +
           ^referent @G10005 + ^structure-type N + ^spelling goal +
           ^number singular +)
    (@G10005 ^property @C62 + ^handle goal +)
    (@C62 ^handle concept + ^type conceptual +)
    (<i2> ^semantics <s4> + ^lt @G10006 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n1> +)
    (<n1> ^handle goal + ^property @C62 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1720-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n2> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n3> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n4> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i2> ^semantics <s5> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n5> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t1592-1
    :chunk
    (state <s1> ^top-state <s2> ^operator <o2>)
   -{ (<s1> ^operator <o*1>)
      (<o*1> ^name evaluate-operator)}
    (<o2> ^constraint-count 2 ^name ground-referent ^constraints <i1>)
    (<i1> ^lt <p4> ^constraint <n1> ^constraint <n2>)
    (<p4> -^demonstrative true ^specifier { << definite universal >> <c6> })
    (<n2> ^handle <c7> ^property <p2>)
    (<n1> ^handle { < <c7> <c5> } ^property <p1>)
    (<s2> ^world <w1>)
    (<w1> ^objects <o3>)
    (<p2> ^{ << name handle >> <c3> } <c4>)
    (<p1> ^{ << name handle >> <c1> } <c2>)
    (<o3> ^object <o1>)
    (<o1> ^predicates <p3>)
    (<p3> ^<c4> <c7> ^<c2> <c5>)
    -->
    (<i1> ^referent <o1> +)
}

sp {chunk*apply*finish-comprehend*t1583-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling block)}
    (<w1> ^spelling block)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling then)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T10026 +
           ^not-merged-receiver <i2> +)
    (@T10026 ^structure-type THEN + ^spelling then +)
    (<i2> ^semantics <s3> + ^lt @T10026 + ^current-word <w2> +
           ^structure-type THEN +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1570-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling red)}
    (<w1> ^spelling red)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling block)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @B13 +
           ^not-merged-receiver <i2> +)
    (@B13 ^referent @P7001 + ^structure-type N + ^spelling block +
           ^number singular +)
    (@P7001 ^property @P7000 + ^handle block +)
    (<i2> ^semantics <s3> + ^lt @B13 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle block + ^property @P7000 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1557-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling red)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @R10048 +
           ^not-merged-receiver <i2> +)
    (@R10048 ^attachment immediate + ^referent @P1001 + ^structure-type ADJ +
           ^spelling red +)
    (@P1001 ^property @P1000 + ^item-type predicate + ^handle red1 +)
    (@P1000 ^item-type property + ^handle color + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @R10048 + ^current-word <w2> +
           ^structure-type ADJ + ^lt-referent <n2> +)
    (<n2> ^handle red1 + ^item-type predicate + ^property @P1000 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1465-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling matched)}
    (<w1> ^spelling matched)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling |.|)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @W23 +
           ^not-merged-receiver <i2> +)
    (@W23 ^delay-retry true + ^structure-type T + ^spelling |.| +)
    (<i2> ^semantics <s5> + ^lt @W23 + ^current-word <w2> +
           ^structure-type T +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1451-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling matched)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @M3 +
           ^not-merged-receiver <i2> +)
    (@M3 ^attachment immediate + ^referent @M4 + ^structure-type ADJ +
           ^spelling matched +)
    (@M4 ^property @C38 + ^handle matched +)
    (@C38 ^handle property + ^type visual +)
    (<i2> ^semantics <s5> + ^lt @M3 + ^current-word <w2> +
           ^structure-type ADJ + ^lt-referent <n2> +)
    (<n2> ^handle matched + ^property @C38 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1433-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling color)}
    (<w1> ^spelling color)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling is)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1413-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
   -{ (<s2> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling then)}
    (<w1> ^spelling then)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<s1> ^item <i2>)
    (<i2> ^lt <i1> ^lt <i3>)
    (<i1> ^structure-type C)
    (<i3> ^structure-type C)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i4> + ^not-merged-assigner <n1> +
           ^not-merged-assigner <n2> + ^not-merged-assigner <n3> +
           ^not-merged-assigner <n4> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n1> ^structure-type N + ^parent-receiver <i4> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n2> ^structure-type ADJ + ^parent-receiver <i4> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n3> ^structure-type PP + ^parent-receiver <i4> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i4> ^semantics <s4> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n4> ^structure-type RCP + ^parent-receiver <i4> + ^lt @D1004 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1351-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling location)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @L12 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s3> + ^lt @L12 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^property @P7000 + ^handle location +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1339-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o4>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling on)
    (<o4> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <o1> ^lt <o3> ^lt <o2>)
    (<o1> ^structure-type P)
    (<o3> ^structure-type P)
    (<o2> ^spelling on)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n2> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n3> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n4> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n5> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1323-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling on)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type RC)
    (<s2> ^structure-type RC)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @O42 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +)
    (<i2> ^semantics <s5> + ^lt @O42 + ^current-word <w2> +
           ^structure-type P +)
    (@O42 ^relation-type binary + ^converts-to PP + ^assigners @O43 +
           ^structure-type P + ^spelling on + ^relation @R1000 +)
    (@O43 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @O43 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1306-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling block)}
    (<w1> ^spelling block)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> ^spelling that)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @S92 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> +)
    (<n2> ^structure-type PP + ^parent-receiver <i2> + ^lt @I119 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @I117 +
           ^current-word <w2> +)
    (<n4> ^structure-type ADV + ^parent-receiver <i2> + ^lt @I116 +
           ^current-word <w2> +)
    (<n5> ^structure-type IS-V + ^parent-receiver <i2> + ^lt @I115 +
           ^current-word <w2> +)
    (<n6> ^structure-type DP + ^parent-receiver <i2> + ^lt @I118 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^lt @S92 + ^current-word <w2> +
           ^structure-type RC +)
    (@S92 ^converts-to RCP + ^assigners @I120 + ^assigners @I119 +
           ^assigners @I118 + ^assigners @I117 + ^assigners @I116 +
           ^assigners @I115 + ^prior-word-first false +
           ^construction that-is-ADJ/DP/PP/C-ADJP-CONJP/RP + ^prior-word D +
           ^current-word that + ^attachment immediate + ^structure-type RC +)
    (@I116 ^referent-type literal + ^optional true +
           ^relative-position after + ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@I115 ^syntactic-structure predicate + ^required true +
           ^structure-type IS-V +)
    (@I120 ^exclusive @I119 + ^exclusive @I118 + ^exclusive @I117 +
           ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type C-ADJ-P +)
    (@I117 ^referent-type literal + ^exclusive @I120 + ^exclusive @I119 +
           ^exclusive @I118 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type ADJ +)
    (@I118 ^referent-type literal + ^exclusive @I120 + ^exclusive @I119 +
           ^exclusive @I117 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type DP +)
    (@I119 ^exclusive @I120 + ^exclusive @I118 + ^exclusive @I117 +
           ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^attachment immediately-follow +
           ^structure-type PP +)
    (<n7> ^structure-type C-ADJ-P + ^parent-receiver <i2> + ^lt @I120 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1275-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n3>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling to)}
    (<w1> ^spelling to)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n3> ^item <i1>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n5> ^lt <n4> ^lt <n2>)
    (<n1> ^spelling equal-to)
    (<n5> ^structure-type P)
    (<n4> ^structure-type P)
    (<n2> ^spelling equal-to)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n6> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n7> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n8> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n9> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1257-1
    :chunk
    (state <s2> ^operator <o1> ^segment <s1>)
    (<o1> ^name comprehend-word ^current-word <w1>)
    (<w1> ^spelling to)
    (<s1> ^not-merged-receiver <i1> ^retrieved-stack <n1>)
    (<i1> -^merged-with true ^lt <a1> ^lt <a2>)
    (<n1> ^item <i1>)
    (<a1> ^spelling equal)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^remove-receiver <i1> +
           ^retrieved-lexical-item @N10021 + ^not-merged-receiver <i2> +
           ^not-merged-assigner <n2> +)
    (<i2> ^semantics <s3> + ^lt @N10021 + ^current-word <w1> +
           ^structure-type P +)
    (@N10021 ^converts-to PP + ^assigners @N10022 + ^prior-word equal +
           ^current-word to + ^structure-type P + ^spelling equal-to +
           ^relation @R1019 +)
    (@N10022 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @N10022 +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1248-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling equal)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10066 +
           ^not-merged-receiver <i2> +)
    (@A10066 ^converts-to PP + ^structure-type P + ^spelling equal +
           ^relation @R1019 +)
    (@R1019 ^handle equal +)
    (<i2> ^semantics <s5> + ^lt @A10066 + ^current-word <w2> +
           ^structure-type P +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1215-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling of)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling a)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type P ^spelling of)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10049 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@A10049 ^super-type @D1001 + ^specifier indefinite + ^spelling a +
           ^number singular +)
    (<n2> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n3> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n4> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p2> + ^structure-type D +)
    (<p2> ^spelling a + ^number singular + ^specifier indefinite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n5> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1199-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling color)}
    (<w1> ^spelling color)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling of)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @O40 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +)
    (@O40 ^super-type @T9000 + ^attachment immediate + ^spelling of +
           ^relation @O39 +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @T9000 +
           ^current-word <w2> + ^lt <p2> + ^structure-type P +)
    (@T9000 ^relation-type binary + ^converts-to PP + ^assigners @P90108 +
           ^structure-type P +)
    (<p2> ^spelling of + ^relation @O39 + ^attachment immediate +
           ^copied yes + ^structure-type P + ^assigners @P90108 +
           ^converts-to PP + ^relation-type binary +)
    (@O39 ^handle of1 +)
    (@P90108 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @P90108 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1183-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling color)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @C63 +
           ^not-merged-receiver <i2> +)
    (@C63 ^syntactic-referent-type ADJ + ^referent @C64 + ^structure-type N +
           ^spelling color + ^number singular +)
    (@C64 ^property @C62 + ^handle color +)
    (@C62 ^handle concept + ^type conceptual +)
    (<i2> ^semantics <s3> + ^lt @C63 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle color + ^property @C62 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1169-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
    (<w1> ^spelling if)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<s1> ^item <i2>)
    (<i2> -^merged-with true ^lt <i1> ^lt <i4> ^lt <i3>)
    (<i1> ^structure-type C)
    (<i4> ^structure-type C)
    (<i3> ^spelling if)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i5> + ^not-merged-assigner <n1> +
           ^not-merged-assigner <n2> + ^not-merged-assigner <n3> +
           ^not-merged-assigner <n4> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n1> ^structure-type ADJ + ^parent-receiver <i5> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n2> ^structure-type N + ^parent-receiver <i5> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n3> ^structure-type RCP + ^parent-receiver <i5> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i5> ^semantics <s4> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (@D1001 ^super-converts-to CP + ^converts-to DP + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (@D1002 ^repeatable true + ^optional true + ^relative-position after +
           ^before @D1005 + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure adjoin + ^structure-type ADJ +)
    (@D1005 ^relative-position after + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure head + ^required true + ^structure-type N +)
    (@D1003 ^optional true + ^relative-position after + ^before @D1004 +
           ^syntactic-structure complement + ^structure-type PP +)
    (@D1004 ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^structure-type RCP +)
    (<n4> ^structure-type PP + ^parent-receiver <i5> + ^lt @D1003 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t1127-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type VP)
    (<i2> ^structure-type T)
    -->
    (<s2> ^comprehension-structure <c1> + ^construction-comprehended <c2> +)
    (<c1> ^processed true + ^type construction + ^successful-query <x1> +
           ^retrieved-lexical-item @V4 + ^not-merged-receiver <i3> +
           ^not-merged-assigner <n1> +)
    (<x1> ^prior-word-first false + ^prior-word VP + ^current-word T +)
    (<i3> ^lt @V4 + ^current-word @V4 + ^structure-type C +)
    (@V4 ^processed true + ^converts-to CP + ^message-type command +
           ^assigners @A10037 + ^prior-word-first false + ^construction VP-T +
           ^prior-word VP + ^current-word T + ^structure-type C +)
    (@A10037 ^syntactic-structure predicate + ^semantic-structure *copy* +
           ^required true + ^structure-type VP +)
    (<n1> ^structure-type VP + ^parent-receiver <i3> + ^lt @A10037 +
           ^current-word @V4 +)
    (<c2> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t1086-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling onto)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type P ^spelling onto)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n2> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n3> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n4> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p2> + ^structure-type D +)
    (<p2> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n5> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t1061-1
    :chunk
    (state <s1> ^top-state <s2> ^operator <o1>)
   -{ (<s1> ^operator <o*1>)
      (<o*1> ^name evaluate-operator)}
    (<o1> ^constraint-count 1 ^name ground-referent ^constraints <i1>)
    (<i1> ^lt <p3> ^constraint <n1>)
    (<p3> -^demonstrative true ^specifier { << definite universal >> <c4> })
    (<s2> ^dialog-world <w1>)
    (<w1> ^objects <o2>)
    (<n1> ^handle <c3> ^property <p1>)
    (<p1> ^{ << name handle >> <c1> } <c2>)
    (<o2> ^object <p4>)
    (<p4> -^dialog-ignore true ^predicates <p2>)
    (<p2> ^<c2> <c3>)
    -->
    (<i1> ^referent <p4> +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t1060-1
    :chunk
    (state <s1> ^top-state <s2> ^operator <o2>)
   -{ (<s1> ^operator <o*1>)
      (<o*1> ^name evaluate-operator)}
    (<o2> ^constraint-count 1 ^name ground-referent ^constraints <i1>)
    (<i1> ^lt <p3> ^constraint <n1>)
    (<p3> -^demonstrative true ^specifier { << definite universal >> <c4> })
    (<n1> ^handle <c3> ^property <p1>)
    (<s2> ^world <w1>)
    (<w1> ^objects <o3>)
    (<p1> ^{ << name handle >> <c1> } <c2>)
    (<o3> ^object <o1>)
    (<o1> ^predicates <p2>)
    (<p2> ^<c2> <c3>)
    -->
    (<i1> ^referent <o1> +)
}

sp {chunk*apply*finish-comprehend*t1053-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling block)}
    (<w1> ^spelling block)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling onto)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @O46 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +)
    (@O46 ^directional true + ^super-type @T9000 + ^spelling onto +
           ^relation @R1000 +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @T9000 +
           ^current-word <w2> + ^lt <p2> + ^structure-type P +)
    (@T9000 ^relation-type binary + ^converts-to PP + ^assigners @P90108 +
           ^structure-type P +)
    (<p2> ^spelling onto + ^relation @R1000 + ^directional true +
           ^copied yes + ^structure-type P + ^assigners @P90108 +
           ^converts-to PP + ^relation-type binary +)
    (@P90108 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @P90108 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1039-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling block)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @B13 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s3> + ^lt @B13 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle block + ^property @P7000 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t1027-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling move)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type V ^spelling move)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n2> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n4> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p2> + ^structure-type D +)
    (<p2> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n5> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete2*onc*t1011-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type C ^current-word <w1>)
    (<i2> ^structure-type V)
    (<w1> ^first-word true)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t1002-1
    :chunk
    (state <s1> ^top-state <s2> ^operator <o1>)
   -{ (<s1> ^operator <o*1>)
      (<o*1> ^name evaluate-operator)}
    (<o1> ^constraint-count 0 ^name ground-referent ^constraints <i1>)
    (<i1> ^lt <y1>)
    (<y1> -^demonstrative true ^specifier personal)
    (<s2> ^world <w1>)
    (<w1> ^robot <r1>)
    -->
    (<i1> ^referent <r1> +)
}

sp {chunk*apply*finish-comprehend*t994-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling can)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling move)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <c1> ^lt <c3> ^lt <c2>)
    (<c1> ^structure-type V-AUX)
    (<c3> ^structure-type V-AUX)
    (<c2> ^spelling can)
    -->
    (<s1> ^comprehension-structure <c4> +)
    (<c4> ^processed true + ^type word + ^retrieved-lexical-item @M23 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +)
    (@M23 ^directional true + ^super-type @T987 + ^referent @A1008 +
           ^spelling move +)
    (<n2> ^structure-type V-AUX + ^parent-receiver <i2> + ^lt @V89 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADV + ^parent-receiver <i2> + ^lt @V93 +
           ^current-word <w2> +)
    (<n4> ^structure-type DP + ^parent-receiver <i2> + ^lt @V88 +
           ^current-word <w2> +)
    (<n5> ^structure-type PP + ^parent-receiver <i2> + ^lt @V92 +
           ^current-word <w2> +)
    (<n6> ^structure-type DP + ^parent-receiver <i2> + ^lt @V90 +
           ^current-word <w2> +)
    (<n7> ^structure-type CONJP + ^parent-receiver <i2> + ^lt @V91 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @T987 +
           ^current-word <w2> + ^lt <p1> + ^structure-type V +
           ^lt-referent <n9> +)
    (@T987 ^converts-to VP + ^semantic-structure action + ^assigners @V93 +
           ^assigners @V92 + ^assigners @V91 + ^assigners @V90 +
           ^assigners @V89 + ^assigners @V88 + ^assigners @V87 +
           ^tense present + ^structure-type V + ^number singular +)
    (<p1> ^spelling move + ^referent @A1008 + ^directional true +
           ^copied yes + ^number singular + ^structure-type V +
           ^tense present + ^assigners @V93 + ^assigners @V92 +
           ^assigners @V91 + ^assigners @V90 + ^assigners @V89 +
           ^assigners @V88 + ^assigners @V87 + ^semantic-structure action +
           ^converts-to VP +)
    (@A1008 ^handle move1 +)
    (@V93 ^optional true + ^relative-position after +
           ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@V92 ^optional true + ^relative-position after +
           ^syntactic-structure complement2 + ^semantic-structure arg2 +
           ^structure-type PP +)
    (@V91 ^copy-structure arg1 + ^repeatable true + ^optional true +
           ^after @V90 + ^syntactic-structure predicate +
           ^semantic-structure *copy* + ^structure-type CONJP +)
    (@V90 ^relative-position after + ^syntactic-structure head +
           ^semantic-structure arg1 + ^required true + ^structure-type DP +)
    (@V89 ^optional true + ^relative-position before +
           ^syntactic-structure nil + ^semantic-structure action-modifier +
           ^structure-type V-AUX +)
    (@V88 ^optional true + ^relative-position before +
           ^syntactic-structure head + ^semantic-structure agent +
           ^structure-type DP +)
    (<n9> ^handle move1 +)
    (@V87 ^optional true + ^relative-position before +
           ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (<n8> ^structure-type ADV + ^parent-receiver <i2> + ^lt @V87 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete2*onc*t975-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type C ^current-word <w1>)
    (<i2> ^structure-type V-AUX)
    (<w1> ^first-word true)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete*onc*t968-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*1>)
      (<c*1> ^first-word true)}
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type DP)
    (<i2> ^structure-type V-AUX)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*finish-comprehend*t959-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling you)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling can)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <y1> ^lt <y3> ^lt <y2>)
    (<y1> ^structure-type DP)
    (<y3> ^structure-type DP)
    (<y2> ^spelling you)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @C85 +
           ^not-merged-receiver <i2> +)
    (@C85 ^referent @C84 + ^structure-type V-AUX + ^spelling can +)
    (@C84 ^handle can +)
    (<i2> ^semantics <s3> + ^lt @C85 + ^current-word <w2> +
           ^structure-type V-AUX + ^lt-referent <n2> +)
    (<n2> ^handle can +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t945-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
   -{ (<s2> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling then)}
    (<w1> ^spelling then)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling you)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s1> ^item <i2>)
    (<i2> ^lt <i1> ^lt <i3>)
    (<i1> ^structure-type C)
    (<i3> ^structure-type C)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @Y10007 +
           ^not-merged-receiver <i4> +)
    (@Y10007 ^super-converts-to CP + ^specifier personal + ^referent @I114 +
           ^structure-type DP + ^spelling you + ^number singular +)
    (@I114 ^property @P90124 + ^handle rosie +)
    (@P90124 ^handle handle + ^type visual +)
    (<i4> ^semantics <s4> + ^lt @Y10007 + ^current-word <w2> +
           ^structure-type DP + ^lt-referent <n1> +)
    (<n1> ^handle rosie + ^property @P90124 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t891-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n3>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling to)}
    (<w1> ^spelling to)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling a)
    (<n3> ^item <i1>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n5> ^lt <n4> ^lt <n2>)
    (<n1> ^spelling adjacent-to)
    (<n5> ^structure-type P)
    (<n4> ^structure-type P)
    (<n2> ^spelling adjacent-to)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10049 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> +)
    (@A10049 ^super-type @D1001 + ^specifier indefinite + ^spelling a +
           ^number singular +)
    (<n6> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n7> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n8> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling a + ^number singular + ^specifier indefinite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n9> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t870-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling adjacent)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type RC)
    (<s2> ^structure-type RC)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10064 +
           ^not-merged-receiver <i2> +)
    (@A10064 ^converts-to PP + ^structure-type P + ^spelling adjacent +
           ^relation @R1018 +)
    (@R1018 ^primary-rtype single + ^argnum 2 + ^predicate-structure @P90084 +
           ^property @G2000 + ^handle adjacent + ^type property +)
    (@P90084 ^conditions @C33 + ^conditions @C32 +)
    (@C33 ^rtype single + ^args @A10025 + ^negative false +
           ^parameter @P90088 + ^result @R10044 + ^attribute prepositions +
           ^name next-to1 + ^type state-pair +)
    (@A10025 ^num 2 + ^2 @C35 + ^1 @C34 +)
    (@P90088 ^num 2 + ^2 @P90090 + ^1 @P90089 +)
    (@P90090 ^param-id 2 + ^type single +)
    (@P90089 ^param-id 1 + ^type single +)
    (@R10044 ^set @R10045 +)
    (@C35 ^rtype single + ^args @A10027 + ^negative false +
           ^parameter @P90093 + ^attribute input-arg + ^name object +)
    (@P90093 ^num 1 + ^1 @P90094 +)
    (@P90094 ^param-id 2 + ^type single +)
    (@C34 ^rtype single + ^args @A10026 + ^negative false +
           ^parameter @P90091 + ^result @R10046 + ^attribute input-arg +
           ^name object +)
    (@P90091 ^num 1 + ^1 @P90092 +)
    (@P90092 ^param-id 1 + ^type single +)
    (@R10046 ^set @R10047 +)
    (@C32 ^rtype single + ^args @A10024 + ^negative true +
           ^parameter @P90085 + ^result @R10042 + ^attribute prepositions +
           ^name diagonal-with1 + ^type state-pair +)
    (@A10024 ^num 2 + ^2 @C35 + ^1 @C34 +)
    (@P90085 ^num 2 + ^2 @P90087 + ^1 @P90086 +)
    (@P90087 ^param-id 2 + ^type single +)
    (@P90086 ^param-id 1 + ^type single +)
    (@R10042 ^set @R10043 +)
    (@G2000 ^item-type property + ^handle property1 + ^type visual +)
    (<i2> ^semantics <s5> + ^lt @A10064 + ^current-word <w2> +
           ^structure-type P +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t857-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling that)}
    (<w1> ^spelling that)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling is)
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type RC)
    (<s2> ^structure-type RC)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s5> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t845-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling location)}
    (<w1> ^spelling location)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> ^spelling that)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @S92 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> +)
    (<n2> ^structure-type PP + ^parent-receiver <i2> + ^lt @I119 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @I117 +
           ^current-word <w2> +)
    (<n4> ^structure-type DP + ^parent-receiver <i2> + ^lt @I118 +
           ^current-word <w2> +)
    (<n5> ^structure-type ADV + ^parent-receiver <i2> + ^lt @I116 +
           ^current-word <w2> +)
    (<n6> ^structure-type IS-V + ^parent-receiver <i2> + ^lt @I115 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^lt @S92 + ^current-word <w2> +
           ^structure-type RC +)
    (@S92 ^converts-to RCP + ^assigners @I120 + ^assigners @I119 +
           ^assigners @I118 + ^assigners @I117 + ^assigners @I116 +
           ^assigners @I115 + ^prior-word-first false +
           ^construction that-is-ADJ/DP/PP/C-ADJP-CONJP/RP + ^prior-word D +
           ^current-word that + ^attachment immediate + ^structure-type RC +)
    (@I116 ^referent-type literal + ^optional true +
           ^relative-position after + ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@I115 ^syntactic-structure predicate + ^required true +
           ^structure-type IS-V +)
    (@I120 ^exclusive @I119 + ^exclusive @I118 + ^exclusive @I117 +
           ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type C-ADJ-P +)
    (@I117 ^referent-type literal + ^exclusive @I120 + ^exclusive @I119 +
           ^exclusive @I118 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type ADJ +)
    (@I118 ^referent-type literal + ^exclusive @I120 + ^exclusive @I119 +
           ^exclusive @I117 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^structure-type DP +)
    (@I119 ^exclusive @I120 + ^exclusive @I118 + ^exclusive @I117 +
           ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^attachment immediately-follow +
           ^structure-type PP +)
    (<n7> ^structure-type C-ADJ-P + ^parent-receiver <i2> + ^lt @I120 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t825-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o4>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling on)
    (<o4> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling a)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <o1> ^lt <o3> ^lt <o2>)
    (<o1> ^structure-type P)
    (<o3> ^structure-type P)
    (<o2> ^spelling on)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10049 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@A10049 ^super-type @D1001 + ^specifier indefinite + ^spelling a +
           ^number singular +)
    (<n2> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n4> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling a + ^number singular + ^specifier indefinite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n5> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t809-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling on)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @O42 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +)
    (<i2> ^semantics <s5> + ^lt @O42 + ^current-word <w2> +
           ^structure-type P +)
    (@O42 ^relation-type binary + ^converts-to PP + ^assigners @O43 +
           ^structure-type P + ^spelling on + ^relation @R1000 +)
    (@O43 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @O43 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t786-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling block)}
    (<w1> ^spelling block)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling is)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (@I8 ^tense present + ^structure-type IS-V + ^spelling is +
           ^number singular +)
    (<i2> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t771-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling a)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling block)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling a)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @B13 +
           ^not-merged-receiver <i2> +)
    (@B13 ^referent @P7001 + ^structure-type N + ^spelling block +
           ^number singular +)
    (@P7001 ^property @P7000 + ^handle block +)
    (@P7000 ^item-type property + ^handle category + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @B13 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle block + ^property @P7000 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t718-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling location)}
    (<w1> ^spelling location)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling |.|)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @W23 +
           ^not-merged-receiver <i2> +)
    (@W23 ^delay-retry true + ^structure-type T + ^spelling |.| +)
    (<i2> ^semantics <s3> + ^lt @W23 + ^current-word <w2> +
           ^structure-type T +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t698-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n3>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling to)}
    (<w1> ^spelling to)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n3> ^item <i1>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n5> ^lt <n4> ^lt <n2>)
    (<n1> ^spelling adjacent-to)
    (<n5> ^structure-type P)
    (<n4> ^structure-type P)
    (<n2> ^spelling adjacent-to)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n6> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n7> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n8> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n9> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t680-1
    :chunk
    (state <s2> ^operator <o1> ^segment <s1>)
    (<o1> ^name comprehend-word ^current-word <w1>)
    (<w1> ^spelling to)
    (<s1> ^not-merged-receiver <i1> ^retrieved-stack <n1>)
    (<i1> -^merged-with true ^lt <a1> ^lt <a2>)
    (<n1> ^item <i1>)
    (<a1> ^spelling adjacent)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^remove-receiver <i1> +
           ^retrieved-lexical-item @N10018 + ^not-merged-receiver <i2> +
           ^not-merged-assigner <n2> +)
    (<i2> ^semantics <s3> + ^lt @N10018 + ^current-word <w1> +
           ^structure-type P +)
    (@N10018 ^converts-to PP + ^assigners @N10017 + ^prior-word adjacent +
           ^current-word to + ^structure-type P + ^spelling adjacent-to +
           ^relation @R1018 +)
    (@N10017 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @N10017 +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t671-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling adjacent)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10064 +
           ^not-merged-receiver <i2> +)
    (@A10064 ^converts-to PP + ^structure-type P + ^spelling adjacent +
           ^relation @R1018 +)
    (@R1018 ^primary-rtype single + ^argnum 2 + ^predicate-structure @P90084 +
           ^property @G2000 + ^handle adjacent + ^type property +)
    (@P90084 ^conditions @C33 + ^conditions @C32 +)
    (@C33 ^rtype single + ^args @A10025 + ^negative false +
           ^parameter @P90088 + ^result @R10044 + ^attribute prepositions +
           ^name next-to1 + ^type state-pair +)
    (@A10025 ^num 2 + ^2 @C35 + ^1 @C34 +)
    (@P90088 ^num 2 + ^2 @P90090 + ^1 @P90089 +)
    (@P90090 ^param-id 2 + ^type single +)
    (@P90089 ^param-id 1 + ^type single +)
    (@R10044 ^set @R10045 +)
    (@C35 ^rtype single + ^args @A10027 + ^negative false +
           ^parameter @P90093 + ^attribute input-arg + ^name object +)
    (@P90093 ^num 1 + ^1 @P90094 +)
    (@P90094 ^param-id 2 + ^type single +)
    (@C34 ^rtype single + ^args @A10026 + ^negative false +
           ^parameter @P90091 + ^result @R10046 + ^attribute input-arg +
           ^name object +)
    (@P90091 ^num 1 + ^1 @P90092 +)
    (@P90092 ^param-id 1 + ^type single +)
    (@R10046 ^set @R10047 +)
    (@C32 ^rtype single + ^args @A10024 + ^negative true +
           ^parameter @P90085 + ^result @R10042 + ^attribute prepositions +
           ^name diagonal-with1 + ^type state-pair +)
    (@A10024 ^num 2 + ^2 @C35 + ^1 @C34 +)
    (@P90085 ^num 2 + ^2 @P90087 + ^1 @P90086 +)
    (@P90087 ^param-id 2 + ^type single +)
    (@P90086 ^param-id 1 + ^type single +)
    (@R10042 ^set @R10043 +)
    (@G2000 ^item-type property + ^handle property1 + ^type visual +)
    (<i2> ^semantics <s5> + ^lt @A10064 + ^current-word <w2> +
           ^structure-type P +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t645-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
   -{ (<s2> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling then)}
    (<w1> ^spelling then)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling it)
    (<s1> ^item <i2>)
    (<i2> ^lt <i1> ^lt <i3>)
    (<i1> ^structure-type C)
    (<i3> ^structure-type C)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I113 +
           ^not-merged-receiver <i4> +)
    (<i4> ^semantics <s4> + ^lt @I113 + ^current-word <w2> +
           ^structure-type DP +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete*onc*t627-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*1>)
      (<c*1> ^first-word true)}
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type CP)
    (<i2> ^structure-type THEN)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t614-1
    :chunk
    (state <s1> ^top-state <s2> ^operator <o1>)
   -{ (<s1> ^operator <o*1>)
      (<o*1> ^name evaluate-operator)}
    (<o1> ^constraint-count 2 ^name ground-referent ^constraints <i1>)
    (<i1> ^lt <p3> ^constraint <n1> ^constraint <n2>)
    (<p3> -^demonstrative true ^specifier { << definite universal >> <c7> })
    (<s2> ^dialog-world <w1>)
    (<w1> ^objects <o2>)
    (<n2> ^handle <c8> ^property <p1>)
    (<n1> ^handle { < <c8> <c6> } ^property <c1>)
    (<p1> ^{ << name handle >> <c4> } <c5>)
    (<c1> ^{ << name handle >> <c2> } <c3>)
    (<o2> ^object <p4>)
    (<p4> -^dialog-ignore true ^predicates <p2>)
    (<p2> ^<c5> <c8> ^<c3> <c6>)
    -->
    (<i1> ^referent <p4> +)
}

sp {chunk*apply*finish-comprehend*t605-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling location)}
    (<w1> ^spelling location)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling then)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T10026 +
           ^not-merged-receiver <i2> +)
    (@T10026 ^structure-type THEN + ^spelling then +)
    (<i2> ^semantics <s3> + ^lt @T10026 + ^current-word <w2> +
           ^structure-type THEN +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t588-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling clear)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @C36 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s3> + ^lt @C36 + ^current-word <w2> +
           ^structure-type ADJ + ^lt-referent <n2> +)
    (<n2> ^handle clear + ^property @C38 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t576-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n3>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling with)}
    (<w1> ^spelling with)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n3> ^item <i1>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n5> ^lt <n4> ^lt <n2>)
    (<n1> ^spelling diagonal)
    (<n5> ^structure-type P)
    (<n4> ^structure-type P)
    (<n2> ^spelling diagonal)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n6> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n7> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n8> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n9> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t558-1
    :chunk
    (state <s2> ^segment <s1> ^segment <s1> ^segment <s1> ^operator <o1>)
    (<s1> ^not-merged-receiver <i1> ^not-merged-receiver <i1>
          ^not-merged-receiver <i1> ^retrieved-stack <n6>)
    (<i1> -^merged-with true ^lt <n5> ^lt <n3> ^lt <n2> ^lt <n4>)
    (<n6> ^item <i1>)
    (<n5> -^consumes-prior-word false ^prior-word diagonal)
    (<n3> -^super-type <s*1> -^alternative-structure <a*1>
          ^prior-word diagonal ^current-word with ^assigners <n1>
          ^structure-type <c3>)
    (<n2> ^spelling diagonal)
    (<o1> ^name comprehend-word ^current-word <w1>)
    (<w1> ^spelling with)
    (<n1> ^structure-type <c2> ^structure-type <c1>)
    -->
    (<s1> ^comprehension-structure <c4> +)
    (<c4> ^processed true + ^type word + ^retrieved-lexical-item <n3> +
           ^remove-receiver <i1> + ^not-merged-receiver <i2> +
           ^not-merged-assigner <n7> +)
    (<i2> ^semantics <s3> + ^lt <n3> + ^current-word <w1> +
           ^structure-type <c3> +)
    (<n7> ^structure-type <c2> + ^parent-receiver <i2> + ^lt <n1> +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-lexical-retrieval-assigner-prior-word-stale*onc*t555-1
    :chunk
    (state <s2> ^segment <s1> ^segment <s1> ^operator <o1>)
    (<s1> ^not-merged-receiver <i1> ^retrieved-stack <n5>
          ^not-merged-assigner <n2>)
    (<i1> -^merged-with true ^lt <n4> ^lt <n1>)
    (<n5> ^item <i1>)
    (<n2> ^parent-receiver <i1> ^lt <n3>)
    (<n4> -^consumes-prior-word false ^prior-word diagonal)
    (<n1> ^spelling diagonal)
    (<o1> ^name comprehend-word ^current-word <w1>)
    (<w1> ^spelling with)
    -->
    (<s1> ^not-merged-assigner <n2> -)
}

sp {chunk*apply*finish-comprehend*t549-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling not)}
    (<w1> ^spelling not)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling diagonal)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @N10020 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +)
    (<i2> ^semantics <s5> + ^lt @N10020 + ^current-word <w2> +
           ^structure-type P +)
    (@N10020 ^converts-to PP + ^assigners @N10019 + ^prior-word diagonal +
           ^current-word with + ^structure-type P + ^spelling diagonal +
           ^relation @R1012 +)
    (@R1012 ^handle diagonal-with1 +)
    (@N10019 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n2> ^structure-type DP + ^parent-receiver <i2> + ^lt @N10019 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t534-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling not)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @N10005 +
           ^not-merged-receiver <i2> +)
    (@N10005 ^referent @N10006 + ^structure-type ADV + ^spelling not +)
    (@N10006 ^handle negation +)
    (<i2> ^semantics <s5> + ^lt @N10005 + ^current-word <w2> +
           ^structure-type ADV + ^lt-referent <n2> +)
    (<n2> ^handle negation +)
    (<w2> ^processed true +)
}

sp {chunk*apply*tested-referent*copy-proto-referent*no-multiple*onc*t519-1
    :chunk
    (state <s3> ^operator <o1> ^segment <s2>)
    (<o1> ^constraint-count 0 ^name ground-referent ^constraints <i3>)
    (<i3> ^lt <i2>)
    (<i2> -^demonstrative true ^specifier it)
    (<s2> ^merged-assigner <n1>)
    (<n1> ^parent-receiver <i1>)
    (<i1> ^semantics <s1>)
    (<s1> ^{ << arg1 agent >> <c2> } <p2>)
   -{ (<s2> ^merged-assigner { < <n1> <ma2> })
      (<ma2> ^parent-receiver <p*2>)
      (<p*2> ^semantics <s*2>)
      (<s*2> ^{ << arg1 agent >> <a*2> } <p2>)}
    (<p2> ^predicates <p1>)
    (<p1> ^category <c1>)
    -->
    (<i3> ^referent <p2> +)
}

sp {chunk*apply*finish-comprehend*t511-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling it)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling is)
    (<n1> ^item <i2>)
    (<i2> -^merged-with true ^lt <i1> ^lt <i4> ^lt <i3>)
    (<i1> ^structure-type DP)
    (<i4> ^structure-type DP)
    (<i3> ^spelling it)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i5> +)
    (<i5> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete2*onc*t499-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type C ^current-word <w1>)
    (<i2> ^structure-type DP)
    (<w1> ^first-word true)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete*onc*t492-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*1>)
      (<c*1> ^first-word true)}
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type C)
    (<i2> ^structure-type DP)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*finish-comprehend*t487-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling but)}
    (<w1> ^spelling but)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling it)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <c1> ^lt <c2>)
    (<c1> ^structure-type C)
    (<c2> ^structure-type C)
    -->
    (<s1> ^comprehension-structure <c3> +)
    (<c3> ^processed true + ^type word + ^retrieved-lexical-item @I113 +
           ^not-merged-receiver <i2> +)
    (@I113 ^super-converts-to CP + ^specifier it + ^structure-type DP +
           ^spelling it + ^number singular +)
    (<i2> ^semantics <s3> + ^lt @I113 + ^current-word <w2> +
           ^structure-type DP +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t472-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type CP)
    (<i2> ^structure-type CP-CONJ)
    -->
    (<s2> ^comprehension-structure <c1> + ^construction-comprehended <c2> +)
    (<c1> ^processed true + ^type construction + ^successful-query <x1> +
           ^retrieved-lexical-item @C88 + ^not-merged-receiver <i3> +
           ^not-merged-assigner <n1> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +)
    (<x1> ^prior-word-first false + ^prior-word CP + ^current-word CP-CONJ +)
    (<n1> ^structure-type CP + ^parent-receiver <i3> + ^lt @A10115 +
           ^current-word @C88 +)
    (<n2> ^structure-type CP-CONJ + ^parent-receiver <i3> + ^lt @A10114 +
           ^current-word @C88 +)
    (<n3> ^structure-type VP + ^parent-receiver <i3> + ^lt @A10117 +
           ^current-word @C88 +)
    (<i3> ^lt @C88 + ^current-word @C88 + ^structure-type C +)
    (@C88 ^processed true + ^converts-to CP + ^assigners @A10117 +
           ^assigners @A10116 + ^assigners @A10115 + ^assigners @A10114 +
           ^prior-word-first false + ^prior-word-first true +
           ^construction CP-CONJ-CP + ^prior-word CP + ^current-word CP-CONJ +
           ^structure-type C +)
    (@A10116 ^embed-structure subclause + ^before @A10115 + ^before @A10114 +
           ^syntactic-structure sentence + ^semantic-structure *embed* +
           ^required true + ^structure-type CP +)
    (@A10115 ^embed-structure subclause + ^exclusive @A10117 +
           ^optional true + ^syntactic-structure sentence +
           ^semantic-structure *embed* + ^structure-type CP +)
    (@A10117 ^embed-structure subclause + ^exclusive @A10115 +
           ^optional true + ^syntactic-structure sentence +
           ^semantic-structure *embed* + ^structure-type VP +)
    (@A10114 ^before @A10115 + ^syntactic-structure CONJ + ^required true +
           ^structure-type CP-CONJ +)
    (<n4> ^structure-type CP + ^parent-receiver <i3> + ^lt @A10116 +
           ^current-word @C88 +)
    (<c2> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t436-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling clear)}
    (<w1> ^spelling clear)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling location)
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @L12 +
           ^not-merged-receiver <i2> +)
    (<i2> ^semantics <s3> + ^lt @L12 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle location + ^property @P7000 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t423-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling a)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling clear)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling a)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @C36 +
           ^not-merged-receiver <i2> +)
    (@C36 ^referent @C37 + ^structure-type ADJ + ^spelling clear +)
    (@C37 ^property @C38 + ^handle clear +)
    (@C38 ^handle property + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @C36 + ^current-word <w2> +
           ^structure-type ADJ + ^lt-referent <n2> +)
    (<n2> ^handle clear + ^property @C38 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t411-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n3>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling to)}
    (<w1> ^spelling to)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling a)
    (<n3> ^item <i1>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n5> ^lt <n4> ^lt <n2>)
    (<n1> ^spelling next-to)
    (<n5> ^structure-type P)
    (<n4> ^structure-type P)
    (<n2> ^spelling next-to)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10049 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> +)
    (@A10049 ^super-type @D1001 + ^specifier indefinite + ^spelling a +
           ^number singular +)
    (<n6> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n7> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n8> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (<p1> ^spelling a + ^number singular + ^specifier indefinite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n9> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t393-1
    :chunk
    (state <s2> ^operator <o1> ^segment <s1>)
    (<o1> ^name comprehend-word ^current-word <w1>)
    (<w1> ^spelling to)
    (<s1> ^not-merged-receiver <i1> ^retrieved-stack <n3>)
    (<i1> -^merged-with true ^lt <n1> ^lt <n2>)
    (<n3> ^item <i1>)
    (<n1> ^spelling next)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^remove-receiver <i1> +
           ^retrieved-lexical-item @N10016 + ^not-merged-receiver <i2> +
           ^not-merged-assigner <n4> +)
    (<i2> ^semantics <s3> + ^lt @N10016 + ^current-word <w1> +
           ^structure-type P +)
    (@N10016 ^converts-to PP + ^assigners @N10015 + ^prior-word next +
           ^current-word to + ^structure-type P + ^spelling next-to +
           ^relation @R1008 +)
    (@N10015 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n4> ^structure-type DP + ^parent-receiver <i2> + ^lt @N10015 +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t384-1
    :chunk
    (state <s4> ^segment <s3> ^operator <o1>)
    (<s3> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s3> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling is)}
    (<w1> ^spelling is)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling next)
   -{ (<s3> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s3> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @N10014 +
           ^not-merged-receiver <i2> +)
    (@N10014 ^converts-to PP + ^structure-type P + ^spelling next +
           ^relation @R1008 +)
    (@R1008 ^handle next-to1 +)
    (<i2> ^semantics <s5> + ^lt @N10014 + ^current-word <w2> +
           ^structure-type P +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t369-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
   -{ (<i1> ^current-word <c*2>)
      (<c*2> ^first-word true)}
    (<i1> ^structure-type DP)
    (<i2> ^structure-type IS-V)
    -->
    (<s2> ^comprehension-structure <c1> + ^construction-comprehended <c2> +)
    (<c1> ^processed true + ^type construction + ^successful-query <x1> +
           ^retrieved-lexical-item @S73 + ^not-merged-receiver <i3> +
           ^not-merged-assigner <n1> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +)
    (<x1> ^prior-word-first false + ^prior-word DP + ^current-word IS-V +)
    (<n1> ^structure-type N + ^parent-receiver <i3> + ^lt @I69 +
           ^current-word @S73 +)
    (<n2> ^structure-type DP + ^parent-receiver <i3> + ^lt @I67 +
           ^current-word @S73 +)
    (<n3> ^structure-type PP + ^parent-receiver <i3> + ^lt @I70 +
           ^current-word @S73 +)
    (<n4> ^structure-type ADJ + ^parent-receiver <i3> + ^lt @I74 +
           ^current-word @S73 +)
    (<n5> ^structure-type C-ADJ-P + ^parent-receiver <i3> + ^lt @I71 +
           ^current-word @S73 +)
    (<n6> ^structure-type ADV + ^parent-receiver <i3> + ^lt @I73 +
           ^current-word @S73 +)
    (<n7> ^structure-type DP + ^parent-receiver <i3> + ^lt @I68 +
           ^current-word @S73 +)
    (<i3> ^lt @S73 + ^current-word @S73 + ^structure-type C +)
    (@S73 ^processed true + ^converts-to CP +
           ^message-type object-description + ^assigners @I74 +
           ^assigners @I73 + ^assigners @I72 + ^assigners @I71 +
           ^assigners @I70 + ^assigners @I69 + ^assigners @I68 +
           ^assigners @I67 + ^prior-word-first false +
           ^construction DP-is-ADJ/DP/PP/CONJP/RP + ^prior-word DP +
           ^current-word IS-V + ^structure-type C +)
    (@I73 ^referent-type literal + ^optional true + ^relative-position after +
           ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@I72 ^syntactic-structure predicate + ^required true +
           ^structure-type IS-V +)
    (@I68 ^referent-type literal + ^exclusive @I74 + ^exclusive @I70 +
           ^exclusive @I69 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^semantic-structure predicate +
           ^structure-type DP +)
    (@I69 ^referent-type literal + ^exclusive @I74 + ^exclusive @I71 +
           ^exclusive @I70 + ^exclusive @I68 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type N +)
    (@I70 ^exclusive @I74 + ^exclusive @I71 + ^exclusive @I69 +
           ^exclusive @I68 + ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^semantic-structure relation +
           ^structure-type PP +)
    (@I71 ^referent-type literal + ^exclusive @I74 + ^exclusive @I70 +
           ^exclusive @I69 + ^exclusive @I68 + ^optional true +
           ^relative-position after + ^syntactic-structure complement +
           ^semantic-structure relation + ^structure-type C-ADJ-P +)
    (@I74 ^referent-type literal + ^exclusive @I71 + ^exclusive @I70 +
           ^exclusive @I69 + ^exclusive @I68 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type ADJ +)
    (@I67 ^relative-position before + ^syntactic-structure head +
           ^semantic-structure arg1 + ^required true + ^structure-type DP +)
    (<n8> ^structure-type IS-V + ^parent-receiver <i3> + ^lt @I72 +
           ^current-word @S73 +)
    (<c2> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t345-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling location)}
    (<w1> ^spelling location)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling is)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (@I8 ^tense present + ^structure-type IS-V + ^spelling is +
           ^number singular +)
    (<i2> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t330-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling a)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling location)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling a)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @L12 +
           ^not-merged-receiver <i2> +)
    (@L12 ^syntactic-referent-type DP + ^referent @P7002 + ^structure-type N +
           ^spelling location + ^number singular +)
    (@P7002 ^property @P7000 + ^handle location +)
    (@P7000 ^item-type property + ^handle category + ^type visual +)
    (<i2> ^semantics <s3> + ^lt @L12 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle location + ^property @P7000 +)
    (<w2> ^processed true +)
}

sp {chunk*comprehend-word*apply*smem-construction-retrieval*failure-complete2*onc*t318-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type C ^current-word <w1>)
    (<i2> ^structure-type D)
    (<w1> ^first-word true)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^failed true + ^type construction +)
}

sp {chunk*apply*finish-comprehend*t311-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
    (<w1> ^spelling if)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling a)
    (<s1> ^item <i2>)
    (<i2> -^merged-with true ^lt <i1> ^lt <i4> ^lt <i3>)
    (<i1> ^structure-type C)
    (<i4> ^structure-type C)
    (<i3> ^spelling if)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10049 +
           ^not-merged-receiver <i5> + ^not-merged-assigner <n1> +
           ^not-merged-assigner <n2> + ^not-merged-assigner <n3> +
           ^not-merged-assigner <n4> +)
    (@A10049 ^super-type @D1001 + ^specifier indefinite + ^spelling a +
           ^number singular +)
    (<n1> ^structure-type N + ^parent-receiver <i5> + ^lt @D1005 +
           ^current-word <w2> +)
    (<n2> ^structure-type ADJ + ^parent-receiver <i5> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n3> ^structure-type RCP + ^parent-receiver <i5> + ^lt @D1004 +
           ^current-word <w2> +)
    (<i5> ^semantics <s4> + ^proto-lt <p1> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p1> + ^structure-type D +)
    (@D1001 ^super-converts-to CP + ^converts-to DP + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^structure-type D +)
    (<p1> ^spelling a + ^number singular + ^specifier indefinite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (@D1002 ^repeatable true + ^optional true + ^relative-position after +
           ^before @D1005 + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure adjoin + ^structure-type ADJ +)
    (@D1005 ^relative-position after + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure head + ^required true + ^structure-type N +)
    (@D1003 ^optional true + ^relative-position after + ^before @D1004 +
           ^syntactic-structure complement + ^structure-type PP +)
    (@D1004 ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^structure-type RCP +)
    (<n4> ^structure-type PP + ^parent-receiver <i5> + ^lt @D1003 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t295-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling *)}
    (<s1> ^prior-word <f1>)
    (<f1> ^spelling *)
    (<o1> ^name comprehend-word ^current-word <w1>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w1> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w1> ^first-word true ^spelling if)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I121 +
           ^not-merged-receiver <i1> + ^not-merged-assigner <n1> +
           ^not-merged-assigner <n2> + ^not-merged-assigner <n3> +)
    (<n1> ^structure-type THEN + ^parent-receiver <i1> + ^lt @I123 +
           ^current-word <w1> +)
    (<n2> ^structure-type CP + ^parent-receiver <i1> + ^lt @I124 +
           ^current-word <w1> +)
    (<i1> ^first-word true + ^semantics <s3> + ^lt @I121 +
           ^current-word <w1> + ^structure-type C +)
    (@I121 ^current-word-first true + ^converts-to CP +
           ^message-type conditional + ^assigners @I124 + ^assigners @I123 +
           ^assigners @I122 + ^structure-type C + ^spelling if +)
    (@I122 ^delay-merge true + ^embed-structure if-subclause +
           ^relative-position after + ^before @I124 + ^before @I123 +
           ^syntactic-structure nil + ^semantic-structure *embed* +
           ^required true + ^structure-type CP +)
    (@I124 ^embed-structure then-subclause + ^syntactic-structure nil +
           ^semantic-structure *embed* + ^required true + ^structure-type CP +)
    (@I123 ^before @I124 + ^syntactic-structure nil + ^required true +
           ^structure-type THEN +)
    (<n3> ^structure-type CP + ^parent-receiver <i1> + ^lt @I122 +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t264-1
    :chunk
    (state <s5> ^segment <s4> ^operator <o1>)
    (<s4> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s3>)
   -{ (<s4> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling slide)}
    (<w1> ^spelling slide)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling |.|)
   -{ (<s4> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s3> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s4> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @W23 +
           ^not-merged-receiver <i2> +)
    (@W23 ^delay-retry true + ^structure-type T + ^spelling |.| +)
    (<i2> ^semantics <s6> + ^lt @W23 + ^current-word <w2> +
           ^structure-type T +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t226-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling action)}
    (<w1> ^spelling action)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling is)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (@I8 ^tense present + ^structure-type IS-V + ^spelling is +
           ^number singular +)
    (<i2> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t213-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling an)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling action)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling an)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10055 +
           ^not-merged-receiver <i2> +)
    (@A10055 ^syntactic-referent-type V + ^object-feature handle +
           ^referent @A10054 + ^structure-type N + ^spelling action +
           ^number singular +)
    (@A10054 ^property @C62 + ^handle action +)
    (<i2> ^semantics <s3> + ^lt @A10055 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle action + ^property @C62 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t201-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling of)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling an)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type P ^spelling of)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @A10050 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@A10050 ^super-type @D1001 + ^specifier indefinite + ^spelling an +
           ^number singular +)
    (<n2> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n4> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p2> + ^structure-type D +)
    (<p2> ^spelling an + ^number singular + ^specifier indefinite +
           ^copied yes + ^super-converts-to CP + ^converts-to DP +
           ^assigners @D1002 + ^assigners @D1003 + ^assigners @D1004 +
           ^assigners @D1005 + ^structure-type D +)
    (<n5> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t161-1
    :chunk
    (state <s2> ^operator <o1> ^segment <s3>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type CP ^current-word <s1>)
    (<i2> ^structure-type T)
    (<s1> ^first-word true)
    -->
    (<s3> ^comprehension-structure <c1> + ^construction-comprehended <c2> +)
    (<c1> ^processed true + ^type construction + ^successful-query <x1> +
           ^retrieved-lexical-item @C61 + ^not-merged-receiver <i3> +
           ^not-merged-assigner <n1> + ^not-merged-assigner <n2> +)
    (<x1> ^prior-word-first true + ^prior-word CP + ^current-word T +)
    (<n1> ^structure-type T + ^parent-receiver <i3> + ^lt @A10034 +
           ^current-word @C61 +)
    (<i3> ^lt @C61 + ^current-word @C61 + ^structure-type S +)
    (@C61 ^processed true + ^assigners @A10034 + ^assigners @A10033 +
           ^prior-word-first false + ^prior-word-first true +
           ^construction CP-T + ^prior-word CP + ^current-word T +
           ^structure-type S +)
    (@A10034 ^after @A10033 + ^syntactic-structure terminator +
           ^required true + ^structure-type T +)
    (@A10033 ^syntactic-structure sentence + ^semantic-structure *copy* +
           ^required true + ^structure-type CP +)
    (<n2> ^structure-type CP + ^parent-receiver <i3> + ^lt @A10033 +
           ^current-word @C61 +)
    (<c2> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t149-1
    :chunk
    (state <s5> ^segment <s4> ^operator <o1>)
    (<s4> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s3>)
   -{ (<s4> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling eight-puzzle)}
    (<w1> ^spelling eight-puzzle)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling |.|)
   -{ (<s4> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s3> ^item <i1>)
    (<i1> ^lt <s1> ^lt <s2>)
    (<s1> ^structure-type C)
    (<s2> ^structure-type C)
    -->
    (<s4> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @W23 +
           ^not-merged-receiver <i2> +)
    (@W23 ^delay-retry true + ^structure-type T + ^spelling |.| +)
    (<i2> ^semantics <s6> + ^lt @W23 + ^current-word <w2> +
           ^structure-type T +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*construction*t118-1
    :chunk
    (state <s1> ^operator <o1> ^segment <s2>)
    (<o1> ^name comprehend-construction ^prior-item <i1> ^current-item <i2>)
    (<i1> ^structure-type DP ^current-word <w1>)
    (<i2> ^structure-type IS-V)
    (<w1> ^first-word true)
    -->
    (<s2> ^comprehension-structure <c1> + ^construction-comprehended <c2> +)
    (<c1> ^processed true + ^type construction + ^successful-query <x1> +
           ^retrieved-lexical-item @S70 + ^not-merged-receiver <i3> +
           ^not-merged-assigner <n1> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> + ^not-merged-assigner <n6> +
           ^not-merged-assigner <n7> + ^not-merged-assigner <n8> +
           ^not-merged-assigner <n9> + ^not-merged-assigner <n10> +
           ^not-merged-assigner <n11> + ^not-merged-assigner <n12> +
           ^not-merged-assigner <n13> + ^not-merged-assigner <n14> +)
    (<x1> ^prior-word-first true + ^prior-word DP + ^current-word IS-V +)
    (<n1> ^structure-type DP + ^parent-receiver <i3> + ^lt @I30 +
           ^current-word @S70 +)
    (<n2> ^structure-type PP + ^parent-receiver <i3> + ^lt @I32 +
           ^current-word @S70 +)
    (<n3> ^structure-type N + ^parent-receiver <i3> + ^lt @I31 +
           ^current-word @S70 +)
    (<n4> ^structure-type V + ^parent-receiver <i3> + ^lt @I39 +
           ^current-word @S70 +)
    (<n5> ^structure-type ADV + ^parent-receiver <i3> + ^lt @I28 +
           ^current-word @S70 +)
    (<n6> ^structure-type RC + ^parent-receiver <i3> + ^lt @I37 +
           ^current-word @S70 +)
    (<n7> ^structure-type IS-V + ^parent-receiver <i3> + ^lt @I27 +
           ^current-word @S70 +)
    (<n8> ^structure-type CONJP + ^parent-receiver <i3> + ^lt @I38 +
           ^current-word @S70 +)
    (<n9> ^structure-type V-AUX + ^parent-receiver <i3> + ^lt @I36 +
           ^current-word @S70 +)
    (<n10> ^structure-type ADJ + ^parent-receiver <i3> + ^lt @I29 +
           ^current-word @S70 +)
    (<n11> ^structure-type DP + ^parent-receiver <i3> + ^lt @I35 +
           ^current-word @S70 +)
    (<n12> ^structure-type C-ADJ-P + ^parent-receiver <i3> + ^lt @I34 +
           ^current-word @S70 +)
    (<n13> ^structure-type U + ^parent-receiver <i3> + ^lt @I33 +
           ^current-word @S70 +)
    (<i3> ^lt @S70 + ^current-word @S70 + ^structure-type C +)
    (@S70 ^processed true + ^converts-to CP +
           ^message-type object-description + ^assigners @I39 +
           ^assigners @I38 + ^assigners @I37 + ^assigners @I36 +
           ^assigners @I35 + ^assigners @I34 + ^assigners @I33 +
           ^assigners @I32 + ^assigners @I31 + ^assigners @I30 +
           ^assigners @I29 + ^assigners @I28 + ^assigners @I27 +
           ^assigners @I26 + ^prior-word-first true +
           ^construction *-DP-is-ADJ/DP/PP/CONJP/RC + ^prior-word DP +
           ^current-word IS-V + ^structure-type C +)
    (@I38 ^copy-structure predicate + ^repeatable true + ^optional true +
           ^syntactic-structure predicate + ^semantic-structure *copy* +
           ^structure-type CONJP +)
    (@I36 ^optional true + ^relative-position after +
           ^syntactic-structure nil + ^semantic-structure modifier +
           ^structure-type V-AUX +)
    (@I28 ^referent-type literal + ^optional true + ^relative-position after +
           ^syntactic-structure adverb-modifier +
           ^semantic-structure modifier + ^structure-type ADV +)
    (@I37 ^embed-structure subclause + ^exclusive @I39 + ^exclusive @I34 +
           ^exclusive @I33 + ^exclusive @I32 + ^exclusive @I31 +
           ^exclusive @I30 + ^exclusive @I29 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure *embed* + ^structure-type RC +)
    (@I29 ^referent-type literal + ^exclusive @I39 + ^exclusive @I37 +
           ^exclusive @I34 + ^exclusive @I33 + ^exclusive @I32 +
           ^exclusive @I31 + ^exclusive @I30 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type ADJ +)
    (@I30 ^referent-type literal + ^exclusive @I39 + ^exclusive @I37 +
           ^exclusive @I34 + ^exclusive @I33 + ^exclusive @I32 +
           ^exclusive @I31 + ^exclusive @I29 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type DP +)
    (@I31 ^referent-type literal + ^exclusive @I39 + ^exclusive @I37 +
           ^exclusive @I34 + ^exclusive @I33 + ^exclusive @I32 +
           ^exclusive @I30 + ^exclusive @I29 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type N +)
    (@I32 ^exclusive @I39 + ^exclusive @I37 + ^exclusive @I34 +
           ^exclusive @I33 + ^exclusive @I31 + ^exclusive @I30 +
           ^exclusive @I29 + ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^semantic-structure relation +
           ^structure-type PP +)
    (@I33 ^predicted-structure-type ADJ + ^referent-type literal +
           ^exclusive @I39 + ^exclusive @I37 + ^exclusive @I34 +
           ^exclusive @I32 + ^exclusive @I31 + ^exclusive @I30 +
           ^exclusive @I29 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^semantic-structure predicate +
           ^structure-type U +)
    (@I39 ^referent-type literal + ^strip-assigners true + ^exclusive @I37 +
           ^exclusive @I34 + ^exclusive @I32 + ^exclusive @I31 +
           ^exclusive @I30 + ^exclusive @I29 + ^optional true +
           ^relative-position after + ^syntactic-structure predicate +
           ^semantic-structure predicate + ^structure-type V +)
    (@I34 ^exclusive @I39 + ^exclusive @I37 + ^exclusive @I33 +
           ^exclusive @I32 + ^exclusive @I31 + ^exclusive @I30 +
           ^exclusive @I29 + ^optional true + ^relative-position after +
           ^syntactic-structure predicate + ^semantic-structure predicate +
           ^structure-type C-ADJ-P +)
    (@I27 ^before @I37 + ^syntactic-structure predicate + ^required true +
           ^structure-type IS-V +)
    (@I35 ^relative-position before + ^syntactic-structure head +
           ^semantic-structure arg1 + ^required true + ^structure-type DP +)
    (@I26 ^copy-structure arg1 + ^repeatable true + ^optional true +
           ^relative-position before + ^before @I27 + ^after @I35 +
           ^syntactic-structure head + ^semantic-structure *copy* +
           ^structure-type CONJP +)
    (<n14> ^structure-type CONJP + ^parent-receiver <i3> + ^lt @I26 +
           ^current-word @S70 +)
    (<c2> ^current-item <i2> + ^prior-item <i1> +)
}

sp {chunk*apply*finish-comprehend*t88-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling game)}
    (<w1> ^spelling game)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling is)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @I8 +
           ^not-merged-receiver <i2> +)
    (@I8 ^tense present + ^structure-type IS-V + ^spelling is +
           ^number singular +)
    (<i2> ^semantics <s3> + ^lt @I8 + ^current-word <w2> +
           ^structure-type IS-V +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t75-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling game)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @G10004 +
           ^not-merged-receiver <i2> +)
    (@G10004 ^syntactic-referent-type DP + ^object-feature handle +
           ^referent @G10003 + ^structure-type N + ^spelling game +
           ^number singular +)
    (@G10003 ^property @C62 + ^handle game1 +)
    (<i2> ^semantics <s3> + ^lt @G10004 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n2> +)
    (<n2> ^handle game1 + ^property @C62 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t63-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
    (<s1> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <n1>)
    (<w1> ^spelling of)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling the)
    (<n1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type P ^spelling of)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n2> +
           ^not-merged-assigner <n3> + ^not-merged-assigner <n4> +
           ^not-merged-assigner <n5> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n2> ^structure-type PP + ^parent-receiver <i2> + ^lt @D1003 +
           ^current-word <w2> +)
    (<n3> ^structure-type ADJ + ^parent-receiver <i2> + ^lt @D1002 +
           ^current-word <w2> +)
    (<n4> ^structure-type N + ^parent-receiver <i2> + ^lt @D1005 +
           ^current-word <w2> +)
    (<i2> ^semantics <s3> + ^proto-lt <p2> + ^super-type @D1001 +
           ^current-word <w2> + ^lt <p2> + ^structure-type D +)
    (<p2> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (<n5> ^structure-type RCP + ^parent-receiver <i2> + ^lt @D1004 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t47-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
   -{ (<s2> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling name)}
    (<w1> ^spelling name)
    (<o1> ^name comprehend-word ^current-word <w2>)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w2> -^first-word true ^spelling of)
    (<s1> ^item <i1>)
    (<i1> ^lt <p1>)
    (<p1> ^structure-type D)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @O40 +
           ^not-merged-receiver <i2> + ^not-merged-assigner <n1> +)
    (@O40 ^super-type @T9000 + ^attachment immediate + ^spelling of +
           ^relation @O39 +)
    (<i2> ^semantics <s4> + ^proto-lt <p2> + ^super-type @T9000 +
           ^current-word <w2> + ^lt <p2> + ^structure-type P +)
    (@T9000 ^relation-type binary + ^converts-to PP + ^assigners @P90108 +
           ^structure-type P +)
    (<p2> ^spelling of + ^relation @O39 + ^attachment immediate +
           ^copied yes + ^structure-type P + ^assigners @P90108 +
           ^converts-to PP + ^relation-type binary +)
    (@O39 ^handle of1 +)
    (@P90108 ^relative-position after + ^syntactic-structure head +
           ^required true + ^structure-type DP +)
    (<n1> ^structure-type DP + ^parent-receiver <i2> + ^lt @P90108 +
           ^current-word <w2> +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t33-1
    :chunk
    (state <s3> ^segment <s2> ^operator <o1>)
    (<s2> -^retry <r*4> ^prior-word <w1> ^retrieved-stack <s1>)
    (<w1> ^spelling the)
    (<o1> ^name comprehend-word ^current-word <w2>)
    (<w2> -^first-word true ^spelling name)
   -{ (<s2> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w2> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<s1> ^item <i1>)
    (<i1> -^merged-with true ^lt <p1>)
    (<p1> ^structure-type D ^spelling the)
    -->
    (<s2> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @N10008 +
           ^not-merged-receiver <i2> +)
    (@N10008 ^syntactic-referent-type N + ^object-feature handle +
           ^referent @N10007 + ^structure-type N + ^spelling name +
           ^number singular +)
    (@N10007 ^property @C62 + ^handle name1 +)
    (@C62 ^handle concept + ^type conceptual +)
    (<i2> ^semantics <s4> + ^lt @N10008 + ^current-word <w2> +
           ^structure-type N + ^lt-referent <n1> +)
    (<n1> ^handle name1 + ^property @C62 +)
    (<w2> ^processed true +)
}

sp {chunk*apply*finish-comprehend*t21-1
    :chunk
    (state <s2> ^segment <s1> ^operator <o1>)
   -{ (<s1> ^retrieved-stack <r*4>)
      (<r*4> ^item <i*1>)
      (<i*1> ^lt <l*1>)
      (<l*1> ^spelling *)}
    (<s1> ^prior-word <f1>)
    (<f1> ^spelling *)
    (<o1> ^name comprehend-word ^current-word <w1>)
   -{ (<s1> ^prior-word <p*1>)
      (<p*1> ^spelling *)
      (<w1> ^next <n*2>)
      (<n*2> ^spelling |.|)}
    (<w1> ^first-word true ^spelling the)
    -->
    (<s1> ^comprehension-structure <c1> +)
    (<c1> ^processed true + ^type word + ^retrieved-lexical-item @T1004 +
           ^not-merged-receiver <i1> + ^not-merged-assigner <n1> +
           ^not-merged-assigner <n2> + ^not-merged-assigner <n3> +
           ^not-merged-assigner <n4> +)
    (@T1004 ^super-type @D1001 + ^specifier definite + ^spelling the +
           ^number singular +)
    (<n1> ^structure-type N + ^parent-receiver <i1> + ^lt @D1005 +
           ^current-word <w1> +)
    (<n2> ^structure-type ADJ + ^parent-receiver <i1> + ^lt @D1002 +
           ^current-word <w1> +)
    (<n3> ^structure-type RCP + ^parent-receiver <i1> + ^lt @D1004 +
           ^current-word <w1> +)
    (<i1> ^first-word true + ^semantics <s3> + ^proto-lt <p1> +
           ^super-type @D1001 + ^current-word <w1> + ^lt <p1> +
           ^structure-type D +)
    (@D1001 ^super-converts-to CP + ^converts-to DP + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^structure-type D +)
    (<p1> ^spelling the + ^number singular + ^specifier definite +
           ^copied yes + ^structure-type D + ^assigners @D1005 +
           ^assigners @D1004 + ^assigners @D1003 + ^assigners @D1002 +
           ^converts-to DP + ^super-converts-to CP +)
    (@D1002 ^repeatable true + ^optional true + ^relative-position after +
           ^before @D1005 + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure adjoin + ^structure-type ADJ +)
    (@D1005 ^relative-position after + ^before @D1004 + ^before @D1003 +
           ^syntactic-structure head + ^required true + ^structure-type N +)
    (@D1003 ^optional true + ^relative-position after + ^before @D1004 +
           ^syntactic-structure complement + ^structure-type PP +)
    (@D1004 ^optional true + ^relative-position after +
           ^syntactic-structure complement + ^structure-type RCP +)
    (<n4> ^structure-type PP + ^parent-receiver <i1> + ^lt @D1003 +
           ^current-word <w1> +)
    (<w1> ^processed true +)
}

sp {chunk*elaborate*clear
    :chunk
    (state <s> ^name game-search ^gtype <gtype> ^<gtype> <g*1>)
    (<g*1> ^condition <co>)
    (<co> ^name clear ^type concept ^attribute predicate)
    -->
    (<s> ^predicate <T5> + ^gtype predicate +)
    (<T5> ^primary-rtype single + ^aname clear + ^nlp-set <nlps> +
           ^formated predicate + ^parameter-set <P124> +
           ^potential-args <P125> + ^link <co> +)
    (<P124> ^argnum 1 +)
    (<nlps> ^conditions <cs> + ^aname clear + ^name clear +)
    (<cs> ^result <r4> + ^name below1 + ^parameter <param1> + ^rtype single +
           ^negative true + ^args <ag> + ^type state-pair +
           ^attribute prepositions +)
    (<r4> ^set <res4> +)
    (<ag> ^1 <c5> + ^2 <c6> + ^num 2 +)
    (<param1> ^1 <p11> + ^num 1 +)
    (<p11> ^param-id 1 + ^type single +)
    (<c5> ^args <A57> + ^attribute input-arg + ^name object +
           ^negative false + ^result <r5> + ^parameter <P225> +
           ^rtype single +)
    (<P225> ^1 <P224> + ^num 1 +)
    (<r5> ^set <res0> +)
    (<P224> ^param-id 1 + ^type single +)
    (<c6> ^args <A56> + ^attribute primitive + ^name object +
           ^negative false + ^parameter <P226> + ^result <R96> +
           ^rtype single + ^type attribute +)
    (<P226> ^num 0 +)
    (<R96> ^set <S156> +)
}