Chunks

(sp chunk-82
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name s-constructor13 ^type s-model-constructor)
  (<p1> ^name create-operator)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-81
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name s-constructor13 ^type s-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))

(sp chunk-80
  :chunk
  (goal <g1> ^problem-space <p3> ^state <s2>)
  (<p3> ^name top-ps)
  (<s2> ^receivers <r1> ^assigners <a2> ^ordering-info <o1>
        ^adjacency-info <a1>)
  (<r1> ^c <c3> ^v <v2>)
  (<c3> ^one <c2>)
  (<a2> ^i <i3> ^v <v4> ^n <n2>)
  (<i3> ^max <i2>)
  (<i2> ^adjoin <i1> ^head <i1>)
  (<c2> ^comp <i1>)
  (<i1> ^cp-projection <c1> ^word-id <f2>)
  (<c1> ^comp *empty* ^word-id <f2>)
  (<v4> ^max <v6> ^zero <v5> ^one <v3>)
  (<v6> ^adjoin <x1>)
  (<x1> ^word-id <f2> ^zero-head <p1>)
  (<p1> ^word-id <f2> ^annotation linked-to-ip ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
  (<v5> ^adjoin <e1>)
  (<e1> ^word-id <f2> ^zero-head <p1>)
  (<v3> ^adjoin <x2> ^comp <x2> ^head <x2>)
  (<x2> ^word-id <f2> ^zero-head <p1> ^comp *empty*)
  (<n2> ^max <n3> ^zero <n1>)
  (<n3> ^adjoin <x3> ^head <x3>)
  (<x3> ^zero-head <p2> ^word-id <f3>)
  (<p2> ^annotation active ^category n ^word-id <f3>)
  (<o1> ^<f3> <f2>)
  (<v2> ^one <v1>)
  (<v1> ^comp <x3>)
  (<n1> ^adjoin <p2>)
  (<a1> ^<f1> <f2>)
-->
  (<g1> ^operator <o2> +)
  (<o2> ^type u-model-constructor + ^name u-constructor10 + ^word-id <f3> &
         ^word-id <f3> + ^word-id <f2> & ^word-id <f2> +
         ^annotation cp-projection & ^annotation cp-projection +))

(sp chunk-79
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name u-constructor10 ^type u-model-constructor)
  (<p1> ^name create-operator)
  (<s1> ^assigners2 <a3> ^receivers2 <r1> ^receivers <r2> ^adjacency-info <a2>
        ^ordering-info <o2> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-78
  :chunk
  (goal <g1> ^problem-space <p1> ^state <s1> ^object <g2>)
  (<p1> ^name u-construct)
  (goal <g2> ^state <s1> ^problem-space <p2> ^operator <o2>)
  (<p2> ^name create-operator)
  (<o2> ^name u-constructor10)
  (<s1> ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2> ^adjacency-info <a2>
        ^ordering-info <o1> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-77
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name u-constructor10 ^type u-model-constructor)
  (<s1> ^assigners <a1>)
  (<a1> ^c <c2>)
  (<c2> ^zero <c4> ^max <c3> ^one <c1>)
  (<c1> ^comp <w1>)
  (<w1> ^projection <w2>)
-->
  (<c1> ^head <w1> +)
  (<c3> ^head <w2> + ^spec <w2> + ^adjoin <w2> +))

(sp chunk-76
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1> ^word-id <f1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty* ^word-id <f1>)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> &))

(sp chunk-75
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty*)
-->
  (<o2> ^annotation cp-projection + ^annotation cp-projection &))

(sp chunk-74
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor ^conjunct-symbol <c3>)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
  (<w1> -^comp <u1> ^comp *empty*)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
-->
  (<o2> ^conjunct-symbol <c3> - ^conjunct-symbol <c4> +))

(sp chunk-73
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^for-formatting <f1> ^assigners <a3>
        ^receivers <r1> ^receivers2 <r2> ^adjacency-info <a2>
        ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty* ^projection <w2>)
-->
  (<w2> ^category c +)
  (<f1> ^nodes <w2> + ^nodes <w2> &))

(sp chunk-72
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2>)
  (<c2> ^max <c3> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty*)
  (<a1> ^c <c4>)
  (<c4> ^one <c5>)
-->
  (<c5> ^comp <w1> +))

(sp chunk-71
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty*)
-->
  (<w1> ^comp <u1> + ^comp <u1> & ^comp *empty* -))

(sp chunk-70
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers2 <r1> ^receivers <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^c <c2> ^i <i1>)
  (<c2> ^one <c3>)
  (<r2> ^c <c4> ^i <i3>)
  (<i3> ^max <i4>)
  (<i1> ^max <i2>)
  (<c4> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^bar-level max ^cp-projection <w1> ^zero-head <w2>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty*)
  (<w2> ^category i)
-->
  (<c1> ^comp <u1> -)
  (<c3> ^comp <u1> -)
  (<i4> ^adjoin <u1> -)
  (<i2> ^adjoin <u1> -))

(sp chunk-69
  :chunk
  (goal <g1> ^state <s1> ^problem-space <p1>)
  (<s1> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<p1> ^name u-construct)
  (<r1> ^c <c2>)
  (<c2> ^one <c1>)
  (<c1> ^comp <u1>)
  (<u1> ^cp-projection <w1>)
 -{ (<w1> ^snip-memory <sm>)
    (<sm> ^receiver <u1> ^role comp)}
  (<w1> ^comp *empty*)
-->
  (<g1> ^operator <c3> +)
  (<c3> ^annotation cp-projection & ^annotation cp-projection +
         ^annotation not-duplicate-relation &
         ^annotation not-duplicate-relation + ^receiver <u1> +
         ^assigner <w1> + ^role comp + ^name link +))

(sp chunk-68
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<a2> ^<f2> <f1>)
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^word-id <f1> ^right-edge <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> & ^word-id <f3> + ^word-id <f3> &))

(sp chunk-67
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^conjunct-symbol conjunct
        ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^left-edge <f3> ^word-id <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<a2> ^<f3> <f1>)
  (<o1> ^<f2> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
  (<u2> -^comp <u3> ^word-id <f1> ^right-edge <f1> ^comp *empty*
        ^zero-head <w1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<o2> ^conjunct-symbol conjunct - ^conjunct-symbol <c1> +))

(sp chunk-66
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^same-sense-sister <u1> ^annotation active ^category n)
  (<a2> ^<f2> { <> <f3> <f1> })
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^right-edge <f1> ^word-id <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1> ^same-sense-sister <w2>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<u1> ^annotation active + ^annotation active & ^annotation inactive -)
  (<w2> ^annotation active + ^annotation active & ^annotation inactive -))

(sp chunk-65
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^same-sense-sister <u1> ^annotation active ^category n)
  (<a2> ^<f2> { <> <f3> <f1> })
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^right-edge <f1> ^word-id <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^same-sense-sister <w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<u1> ^annotation active + ^annotation active & ^annotation inactive -)
  (<w1> ^annotation active + ^annotation active & ^annotation inactive -))

(sp chunk-64
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<a2> ^<f2> { <> <f3> <f1> })
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^word-id <f1> ^right-edge <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1> ^sister <e1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<e1> ^annotation inactive + ^annotation inactive & ^annotation active -))

(sp chunk-63
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n ^sister <e1>)
  (<a2> ^<f2> { <> <f3> <f1> })
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^word-id <f1> ^right-edge <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<e1> ^annotation inactive + ^annotation inactive & ^annotation active -))

(sp chunk-62
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^left-edge <f3> ^word-id <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<a2> ^<f3> <f1>)
  (<o1> ^<f2> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^word-id <f1> ^right-edge <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<u2> ^comp <u3> + ^comp <u3> & ^comp *empty* -))

(sp chunk-61
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers2 <r1> ^receivers <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v3> ^p <p1> ^n <n1> ^i <i1> ^c <c1>)
  (<v3> ^max <v5> ^one <v4>)
  (<r2> ^c <c3> ^i <i3> ^v <v6> ^n <n3> ^p <p3>)
  (<c3> ^max <c4>)
  (<i3> ^max <i4>)
  (<v6> ^max <v7> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^bar-level max ^zero-head <u1> ^left-edge <f3> ^word-id <f2>
        -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<n3> ^max <n4>)
  (<p3> ^one <p4>)
  (<a2> ^<f3> <f1>)
  (<o1> ^<f2> <f1>)
  (<p1> ^one <p2>)
  (<n1> ^max <n2>)
  (<i1> ^max <i2>)
  (<c1> ^max <c2>)
  (<a1> ^v <v8>)
  (<v8> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^word-id <f1> ^right-edge <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<c4> ^spec <u3> -)
  (<c2> ^spec <u3> -)
  (<i4> ^spec <u3> - ^adjoin <u3> -)
  (<i2> ^spec <u3> - ^adjoin <u3> -)
  (<v7> ^spec <u3> -)
  (<v5> ^spec <u3> -)
  (<p4> ^comp <u3> -)
  (<p2> ^comp <u3> -)
  (<v2> ^comp <u3> - ^comp2 <u3> -)
  (<v4> ^comp <u3> - ^comp2 <u3> -)
  (<n4> ^spec <u3> -)
  (<n2> ^spec <u3> -))

(sp chunk-60
  :chunk
  (goal <g1> ^state <s2> ^operator <o2>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor10 ^type u-model-constructor)
  (<r1> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^zero-head <u1> ^word-id <f3> ^left-edge <f2> -^word-id <f1>)
  (<u1> ^annotation active ^category n)
  (<a2> ^<f2> { <> <f3> <f1> })
  (<o1> ^<f3> <f1>)
  (<a1> ^v <v3>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u3>)}
  (<u2> ^right-edge <f1> ^word-id <f1> ^comp *empty* ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<s2> ^receivers-ids <f3> -))

(sp chunk-59
  :chunk
  (goal <g1> ^state <s2> ^problem-space <p1>)
  (<s2> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^assigners <a2> ^ordering-info <o1> ^adjacency-info <a1>)
  (<p1> ^name u-construct)
  (<r1> ^v <v3>)
  (<a2> ^v <v4>)
  (<v4> ^one <v2>)
  (<v2> ^comp <u3>)
  (<u3> ^comp *empty* ^word-id <f2> ^right-edge <f2> ^zero-head <w1>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
  (<o1> ^<f3> <f2>)
  (<v3> ^one <v1>)
  (<v1> ^comp { <> <u3> <u2> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role comp ^receiver <u2>)}
  (<u2> -^word-id <f2> ^word-id <f3> ^zero-head <u1> ^left-edge <f1>)
  (<u1> ^annotation active ^category n)
  (<a1> ^<f1> <f2>)
-->
  (<g1> ^operator <c1> +)
  (<c1> ^receiver <u2> + ^assigner <u3> + ^role comp + ^name link +
         ^annotation not-duplicate-relation &
         ^annotation not-duplicate-relation +))

(sp chunk-58
  :chunk
  (goal <g1> ^state <s2> ^operator <o2> ^operator <o2> + ^problem-space <p1>)
  (<s2> ^name generator-state ^ordering-info <o1> ^adjacency-info <a1>)
  (<o2> -^annotation constraints-passed ^constructed-operator <c1>)
  (<p1> ^name generator)
  (<c1> ^annotation not-duplicate-relation ^name link ^role comp
        ^assigner <u3> ^receiver <u2>)
  (<u3> ^word-id <f2> ^zero-head <w1>)
  (<u2> ^zero-head <u1> ^word-id <f1>)
  (<u1> ^category n)
  (<o1> ^<f1> <f2>)
  (<w1> ^subcat <s1>)
  (<s1> -^n <x*1> -^feature <f*1> ^subcat n)
-->
  (<o2> ^annotation constraints-passed + ^annotation constraints-passed &))

(sp chunk-57
  :chunk
  (goal <g1> ^state <s1> ^operator <o2> + ^problem-space <p1>)
  (<s1> ^name generator-state ^ordering-info <o1> ^adjacency-info <a1>)
  (<o2> -^annotation constraints-passed ^constructed-operator <c1>)
  (<p1> ^name generator)
  (<c1> ^name link ^role spec ^assigner <u1> ^receiver <u2>)
 -{ (<u1> ^annotation dominates-trace ^zero-head <z*1>)
    (<z*1> ^category i)}
  (<u1> ^word-id <f1>)
  (<u2> ^word-id <f2>)
  (<o1> -^<f1> <f2>)
-->
  (<g1> ^operator <o2> -)
  (<o2> ^annotation failure + ^annotation failure &))

(sp chunk-56
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name u-constructor10 ^type u-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))

(sp chunk-55
  :chunk
  (goal <g1> ^problem-space <p2> ^state <s1>)
  (<p2> ^name top-ps)
  (<s1> ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<a1> ^v <v2>)
  (<v2> ^max <v1>)
  (<v1> ^adjoin <x1> ^head <x1>)
  (<x1> ^zero-head <p1> ^word-id <f1>)
  (<p1> ^annotation linked-to-ip)
-->
  (<g1> ^operator <o2> +)
  (<o2> ^type s-model-constructor + ^name s-constructor9 +))

(sp chunk-54
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name s-constructor9 ^type s-model-constructor)
  (<p1> ^name create-operator)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-53
  :chunk
  (goal <g1> ^state <s1> ^operator <o1>)
  (<s1> ^name initial-state ^assigners <a1>)
  (<o1> ^name s-constructor9 ^conjunct-symbol conjunct
        ^type s-model-constructor)
  (<a1> ^v <v2>)
  (<v2> ^max <v1>)
  (<v1> ^head <u1>)
  (<u1> -^referent <r*1> ^zero-head <w1>)
  (<w1> -^root be)
-->
  (<o1> ^conjunct-symbol conjunct - ^conjunct-symbol <c1> +))

(sp chunk-52
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name s-constructor9 ^type s-model-constructor)
  (<s1> ^assigners <a1>)
  (<a1> ^v <v2>)
  (<v2> ^max <v1>)
  (<v1> ^head <u1>)
  (<u1> -^referent <r*1> ^zero-head <w1>)
  (<w1> -^root be)
-->
  (<u1> ^referent <r1> + ^referent <r1> &)
  (<r1> ^referent-of <u1> + ^type s-model +))

(sp chunk-51
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name s-constructor9 ^type s-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))

(sp chunk-50
  :chunk
  (goal <g1> ^problem-space <p4> ^state <s1>)
  (<p4> ^name top-ps)
  (<s1> ^assigners <a4> ^adjacency-info <a2> ^ordering-info <o1>
        ^receivers <r1>)
  (<a4> ^v <v2> ^n <n2>)
  (<v2> ^zero <v6> ^one <v5> ^max <v1>)
  (<v6> ^adjoin <p1>)
  (<p1> -^annotation trace -^adjoin <a*1> ^zero-head <p1> ^category v
        ^bar-level zero ^word-id <f1> ^left-edge <f1> ^right-edge <f1>
        ^projection <x1> ^empty-node <e1>)
  (<x1> ^word-id <f1> ^head <p1>)
  (<v5> ^adjoin <x1> ^head <x1>)
  (<n2> ^zero <n3> ^max <n1>)
  (<n3> ^adjoin <p3>)
  (<p3> ^agr <a3> ^word-id <f2>)
  (<a3> ^number singular)
  (<a2> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i3> ^v <v4>)
  (<i3> ^one <i4> ^max <i2>)
  (<i4> ^comp <x2>)
  (<x2> ^word-id <f1> ^head <x1>)
  (<v1> ^adjoin <x2> ^head <x2>)
  (<i2> ^spec <x3>)
  (<x3> ^word-id <f2> ^zero-head <p3>)
  (<n1> ^adjoin <x3> ^head <x3>)
  (<v4> ^zero <v3>)
  (<v3> ^adjoin <p2>)
  (<p2> -^annotation trace -^adjoin <a*1> ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^category v ^bar-level zero ^agr <a1> ^tense <t1>
        ^index <i1>)
  (<a1> ^number singular)
-->
  (<g1> ^operator <o2> +)
  (<o2> ^type u-model-constructor + ^name u-constructor6 + ^word-id <f2> &
         ^word-id <f2> + ^word-id <f1> & ^word-id <f1> +))

(sp chunk-49
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name u-constructor6 ^type u-model-constructor)
  (<p1> ^name create-operator)
  (<s1> ^assigners2 <a3> ^receivers2 <r1> ^receivers <r2> ^adjacency-info <a2>
        ^ordering-info <o2> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-48
  :chunk
  (goal <g1> ^problem-space <p1> ^state <s1> ^object <g2>)
  (<p1> ^name u-construct)
  (goal <g2> ^state <s1> ^problem-space <p2> ^operator <o2>)
  (<p2> ^name create-operator)
  (<o2> ^name u-constructor6)
  (<s1> ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2> ^adjacency-info <a2>
        ^ordering-info <o1> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-47
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> & ^word-id <f2> + ^word-id <f2> &))

(sp chunk-46
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor ^conjunct-symbol <c1>)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>
        -^spec <u2>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<o2> ^conjunct-symbol <c1> - ^conjunct-symbol <c2> +))

(sp chunk-45
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<i2> ^annotation specified + ^annotation specified &))

(sp chunk-44
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> { <> <f1> <f2> })
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^right-edge <f2> ^word-id <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2> ^sister <e1>)
  (<a2> ^number singular)
-->
  (<e1> ^annotation inactive + ^annotation inactive & ^annotation active -))

(sp chunk-43
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<i2> ^spec <u2> + ^spec <u2> & ^spec *empty* -))

(sp chunk-42
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers2 <r1> ^receivers <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i8>)
  (<i8> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f1> ^left-edge <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i5> ^v <v1> ^p <p1> ^n <n1> ^c <c1>)
  (<i5> ^max <i6>)
  (<r2> ^c <c3> ^i <i7> ^v <v4> ^n <n3> ^p <p3>)
  (<c3> ^max <c4>)
  (<i7> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^bar-level max
        ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^category n ^agr <a2>)
  (<a2> ^number singular)
  (<v4> ^max <v6> ^one <v5>)
  (<n3> ^max <n4>)
  (<p3> ^one <p4>)
  (<v1> ^max <v3> ^one <v2>)
  (<p1> ^one <p2>)
  (<n1> ^max <n2>)
  (<c1> ^max <c2>)
-->
  (<c4> ^spec <u2> -)
  (<c2> ^spec <u2> -)
  (<i4> ^spec <u2> - ^adjoin <u2> -)
  (<i6> ^spec <u2> - ^adjoin <u2> -)
  (<v6> ^spec <u2> -)
  (<v3> ^spec <u2> -)
  (<p4> ^comp <u2> -)
  (<p2> ^comp <u2> -)
  (<v5> ^comp <u2> - ^comp2 <u2> -)
  (<v2> ^comp <u2> - ^comp2 <u2> -)
  (<n4> ^spec <u2> -)
  (<n2> ^spec <u2> -))

(sp chunk-41
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^ordering-info <o1> ^receivers <r1> ^receivers2 <r2>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<a3> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec <i2>)
  (<i2> ^spec *empty* ^left-edge <f1> ^word-id <f1> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a4> ^<f1> { <> <f1> <f2> })
  (<o1> ^<f1> <f2>)
  (<r1> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f1> ^word-id <f2> ^right-edge <f2> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<s1> ^receivers-ids <f2> -))

(sp chunk-40
  :chunk
  (goal <g1> ^state <s1> ^problem-space <p1>)
  (<s1> ^name initial-state ^assigners2 <a5> ^assigners <a4>
        ^adjacency-info <a3> ^ordering-info <o1> ^receivers <r1>
        ^receivers2 <r2>)
  (<p1> ^name u-construct)
  (<a4> ^i <i6>)
  (<i6> ^max <i4>)
  (<i4> ^spec <i2>)
  (<i2> ^spec *empty* ^word-id <f2> ^left-edge <f2> ^zero-head <i1>)
  (<i1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a3> ^<f2> <f1>)
  (<o1> ^<f2> <f1>)
  (<r1> ^i <i5>)
  (<i5> ^max <i3>)
  (<i3> ^spec { <> <i2> <u2> })
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u2>)}
  (<u2> -^word-id <f2> ^word-id <f1> ^right-edge <f1> ^zero-head <u1>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<u1> ^agr <a2>)
  (<a2> ^number singular)
-->
  (<g1> ^operator <c1> +)
  (<c1> ^receiver <u2> + ^assigner <i2> + ^role spec + ^name link +
         ^annotation not-duplicate-relation &
         ^annotation not-duplicate-relation +))

(sp chunk-39
  :chunk
  (goal <g1> ^state <s1> ^operator <o2> ^operator <o2> + ^problem-space <p1>)
  (<s1> ^name generator-state ^ordering-info <o1> ^adjacency-info <a3>)
  (<o2> -^annotation constraints-passed ^constructed-operator <c1>)
  (<p1> ^name generator)
  (<c1> ^annotation not-duplicate-relation ^name link ^role spec
        ^assigner <i2> ^receiver <u2>)
  (<i2> ^zero-head <i1> ^word-id <f2>)
  (<i1> -^category c ^agr <a2>)
 -{ (<u2> -^annotation trace)
    (<i1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <i2>)}
 -{ (<u2> -^annotation trace)
    (<i1> ^annotation empty)}
  (<a2> ^number singular)
  (<u2> ^word-id <f1> ^zero-head <u1>)
  (<o1> ^<f2> <f1>)
  (<u1> ^agr <a1>)
  (<a1> ^number singular)
-->
  (<o2> ^annotation constraints-passed + ^annotation constraints-passed &))

(sp chunk-38
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^i <i3>)
  (<i3> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^word-id <f1> ^head <u2>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role comp)}
  (<i1> ^word-id <f1> ^comp *empty*)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> &))

(sp chunk-37
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor ^conjunct-symbol <c1>)
  (<r1> ^i <i3>)
  (<i3> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^head <u2>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
  (<i1> -^comp <u3> ^comp *empty*)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role comp)}
-->
  (<o2> ^conjunct-symbol <c1> - ^conjunct-symbol <c2> +))

(sp chunk-36
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^i <i3>)
  (<i3> ^max <i4> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^word-id <f1> ^head <u2>)
  (<u2> ^head <e1>)
  (<e1> ^category v ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role comp)}
  (<i1> ^word-id <f1> ^bar-level one ^comp *empty*)
  (<a1> ^i <i5>)
  (<i5> ^one <i6>)
-->
  (<i6> ^comp <i1> +))

(sp chunk-35
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^i <i3>)
  (<i3> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^head <u2>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role comp)}
  (<i1> ^comp *empty*)
-->
  (<i1> ^comp <u3> + ^comp <u3> & ^comp *empty* -))

(sp chunk-34
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^i <i4>)
  (<i4> ^one <i3>)
  (<i3> ^comp <u4>)
  (<u4> ^bar-level max ^zero-head <u3> ^head <u2>)
  (<u3> ^category v)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i2>)
 -{ (<i2> ^snip-memory <sm>)
    (<sm> ^receiver <u4> ^role comp)}
  (<i2> ^bar-level one ^comp *empty* ^zero-head <i1>)
  (<i1> ^category i)
-->
  (<u3> ^annotation linked-to-ip + ^annotation linked-to-ip &))

(sp chunk-33
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners <a3> ^receivers2 <r1> ^receivers <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^i <i3> ^v <v1>)
  (<i3> ^one <i4>)
  (<r2> ^i <i5> ^v <v3>)
  (<i5> ^one <i2>)
  (<i2> ^comp <u4>)
  (<u4> ^bar-level max ^zero-head <u3> ^head <u2>)
  (<u3> ^category v)
  (<v3> ^one <v4>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u4> ^role comp)}
  (<i1> ^comp *empty*)
  (<v1> ^one <v2>)
-->
  (<i2> ^comp <u4> -)
  (<i4> ^comp <u4> -)
  (<v4> ^comp <u4> - ^comp2 <u4> -)
  (<v2> ^comp <u4> - ^comp2 <u4> -))

(sp chunk-32
  :chunk
  (goal <g1> ^state <s1> ^problem-space <p1>)
  (<s1> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<p1> ^name u-construct)
  (<r1> ^i <i3>)
  (<i3> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^head <u2>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^downward-movement-projection <i1>)
 -{ (<i1> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role comp)}
  (<i1> ^comp *empty*)
-->
  (<g1> ^operator <c1> +)
  (<c1> ^annotation matrix & ^annotation matrix + ^annotation projection &
         ^annotation projection + ^annotation not-duplicate-relation &
         ^annotation not-duplicate-relation + ^receiver <u3> +
         ^assigner <i1> + ^role comp + ^name link +))

(sp chunk-31
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name u-constructor6 ^type u-model-constructor)
  (<s1> ^receivers <r1> ^assigners <a2>)
  (<r1> ^i <i3>)
  (<i3> ^one <i2>)
  (<i2> ^comp <u3>)
  (<u3> ^head <u2>)
  (<a2> ^i <i4>)
  (<i4> ^one <i7> ^zero <i6> ^max <i5>)
  (<u2> ^head <e1>)
  (<e1> ^adjoin <u1>)
  (<u1> ^word-id <f1> ^tense <t1> ^index <i1> ^agr <a1>)
-->
  (<u1> ^downward-movement-projection <i8> +)
  (<i7> ^head <i8> + ^comp <i8> +)
  (<i5> ^head <i9> + ^spec <i9> + ^adjoin <i9> +)
  (<i8> ^word-id <f1> + ^bar-level one + ^head <i10> + ^head <i10> &
         ^comp *empty* + ^zero-head <i10> + ^category i + ^projection <i9> +)
  (<i10> ^word-id <f1> + ^bar-level zero + ^sense zero + ^complements one +
         ^zero-head <i10> + ^subcat <s2> + ^agr <a1> + ^tense <t1> +
         ^category i + ^annotation trace + ^annotation trace &
         ^annotation dominates-trace + ^annotation dominates-trace &
         ^annotation active + ^annotation active & ^index <i1> +
         ^left-edge <f1> + ^right-edge <f1> + ^label <l1> +)
  (<s2> ^subcat v + ^subcat v &)
  (<l1> ^label t +)
  (<i9> ^word-id <f1> + ^bar-level max + ^head <i8> + ^head <i8> &
         ^spec *empty* + ^cp-projection <c1> + ^category i +
         ^zero-head <i10> + ^empty-node <e2> +)
  (<c1> ^bar-level one + ^word-id <f1> + ^zero-head <c2> + ^comp *empty* +
         ^head <c2> + ^head <c2> & ^category c + ^projection <c3> +)
  (<c3> ^word-id <f1> + ^bar-level max + ^spec *empty* + ^head <c1> +
         ^head <c1> & ^zero-head <c2> + ^empty-node <e3> +)
  (<c2> ^bar-level zero + ^category c + ^complements one + ^subcat <s3> +
         ^word-id <f1> + ^sense zero + ^annotation empty + ^annotation empty &
         ^annotation active + ^annotation active & ^label <l2> +
         ^left-edge <f1> + ^right-edge <f1> +)
  (<s3> ^subcat i + ^subcat i &)
  (<l2> ^label empty +))

(sp chunk-30
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^v <v3>)
  (<v3> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v4>)
  (<v4> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation linked-to-ip ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^category v ^bar-level zero ^projection <u1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> &))

(sp chunk-29
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^v <v3>)
  (<v3> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v4>)
  (<v4> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation adjoined -^annotation linked-to-ip ^word-id <f1>
        ^left-edge <f1> ^right-edge <f1> ^category v ^bar-level zero
        ^projection <u1> ^empty-node <e1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<u1> ^head <u2> - ^head <e1> + ^head <e1> &))

(sp chunk-28
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor6 ^conjunct-symbol conjunct
        ^type u-model-constructor)
  (<r1> ^v <v3>)
  (<v3> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v4>)
  (<v4> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation adjoined -^annotation linked-to-ip ^word-id <f1>
        ^left-edge <f1> ^right-edge <f1> ^category v ^bar-level zero
        ^projection <u1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<o2> ^conjunct-symbol conjunct - ^conjunct-symbol <c1> +))

(sp chunk-27
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^for-formatting <f2> ^adjacency-info <a3>
        ^receivers <r1> ^receivers2 <r2> ^assigners2 <a2> ^ordering-info <o1>
        ^assigners <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^v <v3>)
  (<v3> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v4>)
  (<v4> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation adjoined -^annotation linked-to-ip ^word-id <f1>
        ^left-edge <f1> ^right-edge <f1> ^category v ^bar-level zero
        ^projection <u1> ^empty-node <e1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<e1> ^category v +)
  (<f2> ^nodes <e1> + ^nodes <e1> &))

(sp chunk-26
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers <r1>
        ^receivers2 <r2> ^assigners <a2> ^ordering-info <o1> ^assigners2 <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^v <v6>)
  (<a2> ^v <v5>)
  (<v5> ^zero <v2>)
  (<v2> ^adjoin <u2>)
  (<u2> -^annotation adjoined -^annotation linked-to-ip ^zero-head <u2>
        ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^projection <u1> ^empty-node <e1>)
  (<u1> ^head <u2>)
  (<v6> ^zero <v1>)
  (<v1> ^adjoin { <> <u2> <u3> })
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^right-edge <f1> ^category v
        ^bar-level zero ^tense <t1>)
  (<a1> ^v <v3>)
  (<v3> ^zero <v4>)
-->
  (<e1> ^adjunction-head <u2> + ^adjoin <u3> + ^zero-head <u2> +
         ^word-id <f1> + ^bar-level zero + ^empty-node <e2> +)
  (<u2> ^empty-node <e1> - ^empty-node <e3> + ^annotation adjoined +
         ^annotation adjoined &)
  (<v2> ^adjoin <u2> - ^adjoin <u3> - ^adjoin <e1> +)
  (<v4> ^adjoin <u2> - ^adjoin <u3> -))

(sp chunk-25
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^adjacency-info <a3> ^receivers2 <r1>
        ^receivers <r2> ^assigners2 <a2> ^ordering-info <o1> ^assigners <a1>)
  (<o2> ^name u-constructor6 ^type u-model-constructor)
  (<r1> ^v <v3>)
  (<v3> ^one <v5> ^zero <v4>)
  (<r2> ^v <v6>)
  (<v6> ^one <v7> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v8>)
  (<v8> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation linked-to-ip ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^category v ^bar-level zero ^projection <u1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<v7> ^head <u3> -)
  (<v5> ^head <u3> -)
  (<v1> ^adjoin <u3> -)
  (<v4> ^adjoin <u3> -))

(sp chunk-24
  :chunk
  (goal <g1> ^state <s1> ^problem-space <p1>)
  (<s1> ^name initial-state ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2>
        ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<p1> ^name u-construct)
  (<r1> ^v <v3>)
  (<v3> ^zero <v1>)
  (<v1> ^adjoin <u3>)
  (<u3> ^category v ^bar-level zero ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^tense <t1>)
  (<a1> ^v <v4>)
  (<v4> ^zero <v2>)
  (<v2> ^adjoin { <> <u3> <u2> })
  (<u2> -^annotation linked-to-ip ^word-id <f1> ^left-edge <f1>
        ^right-edge <f1> ^category v ^bar-level zero ^projection <u1>)
 -{ (<u2> ^snip-memory <sm>)
    (<sm> ^receiver <u3> ^role adjoin)}
  (<u1> ^head <u2>)
-->
  (<g1> ^operator <c1> +)
  (<c1> ^receiver <u3> + ^assigner <u2> + ^role adjoin + ^name link +
         ^parent <u1> + ^annotation parent-update &
         ^annotation parent-update + ^annotation tense-glomming &
         ^annotation tense-glomming +))

(sp chunk-23
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name u-constructor6 ^type u-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))

(sp chunk-22
  :chunk
  (goal <g1> ^problem-space <p1> ^state <s1>)
  (<p1> ^name top-ps)
  (<s1> ^adjacency-info <a2> ^ordering-info <o1> ^assigners <a1>)
  (<a1> ^n <n2>)
  (<n2> ^max <n1>)
  (<n1> ^head <x1>)
  (<x1> ^word-id <f1>)
-->
  (<g1> ^operator <o2> +)
  (<o2> ^type s-model-constructor + ^name s-constructor4 +))

(sp chunk-21
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name s-constructor4 ^type s-model-constructor)
  (<p1> ^name create-operator)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-20
  :chunk
  (goal <g1> ^state <s1> ^operator <o1>)
  (<s1> ^name initial-state ^assigners <a1>)
  (<o1> ^name s-constructor4 ^conjunct-symbol conjunct
        ^type s-model-constructor)
  (<a1> ^n <n2>)
  (<n2> ^max <n1>)
  (<n1> ^head <u1>)
  (<u1> -^referent <r*1>)
-->
  (<o1> ^conjunct-symbol conjunct - ^conjunct-symbol <c1> +))

(sp chunk-19
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name s-constructor4 ^type s-model-constructor)
  (<s1> ^assigners <a1>)
  (<a1> ^n <n2>)
  (<n2> ^max <n1>)
  (<n1> ^head <u1>)
  (<u1> -^referent <r*1>)
-->
  (<u1> ^referent <r1> + ^referent <r1> &)
  (<r1> ^referent-of <u1> + ^type s-model +))

(sp chunk-18
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name s-constructor4 ^type s-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))

(sp chunk-17
  :chunk
  (goal <g1> ^problem-space <p3> ^state <s1>)
  (<p3> ^name top-ps)
  (<s1> ^assigners <a4> ^ordering-info <o1> ^adjacency-info <a1>
        ^receivers <r1>)
  (<a4> ^det <d2> ^n <n4>)
  (<d2> ^zero <d3> ^max <d1>)
  (<n4> ^zero <n5> ^max <n3>)
  (<n5> ^adjoin <p1>)
  (<p1> ^annotation active ^agr <a2> ^word-id <f1>)
  (<a2> ^number singular)
  (<n3> ^adjoin <x1> ^spec <x1> ^head <x1>)
  (<x1> ^zero-head <p1> ^spec *empty* ^word-id <f1>)
  (<d3> ^adjoin <p2>)
  (<p2> ^agr <a3> ^word-id <f2>)
  (<a3> ^number singular-plural)
  (<o1> ^<f1> <f2>)
  (<a1> ^<f1> <f2>)
  (<r1> ^n <n2>)
  (<d1> ^adjoin <x2> ^head <x2>)
  (<x2> ^word-id <f2> ^zero-head <p2>)
  (<n2> ^max <n1>)
  (<n1> ^spec <x2>)
-->
  (<g1> ^operator <o2> +)
  (<o2> ^type u-model-constructor + ^name u-constructor1 + ^word-id <f2> &
         ^word-id <f2> + ^word-id <f1> & ^word-id <f1> +))

(sp chunk-16
  :chunk
  (goal <g1> ^operator <o1> ^problem-space <p1> ^state <s1>)
  (<o1> ^name u-constructor1 ^type u-model-constructor)
  (<p1> ^name create-operator)
  (<s1> ^assigners2 <a3> ^receivers2 <r1> ^receivers <r2> ^adjacency-info <a2>
        ^ordering-info <o2> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-15
  :chunk
  (goal <g1> ^problem-space <p1> ^state <s1> ^object <g2>)
  (<p1> ^name u-construct)
  (goal <g2> ^state <s1> ^problem-space <p2> ^operator <o2>)
  (<p2> ^name create-operator)
  (<o2> ^name u-constructor1)
  (<s1> ^assigners2 <a3> ^receivers <r1> ^receivers2 <r2> ^adjacency-info <a2>
        ^ordering-info <o1> ^assigners <a1>)
-->
  (<s1> ^annotation construction-done + ^annotation construction-done &))

(sp chunk-14
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<o2> ^word-id <f1> + ^word-id <f1> & ^word-id <f2> + ^word-id <f2> &))

(sp chunk-13
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^conjunct-symbol conjunct
        ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
  (<u3> -^spec <u4> ^word-id <f1> ^left-edge <f1> ^spec *empty*
        ^zero-head <u1>)
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<o2> ^conjunct-symbol conjunct - ^conjunct-symbol <c1> +))

(sp chunk-12
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<u3> ^annotation specified + ^annotation specified &))

(sp chunk-11
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u1>)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<u1> ^agr <a1>)
  (<a1> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u2>)
  (<u2> -^category c ^annotation active ^category n ^agr <a2>)
 -{ (<u4> -^annotation trace)
    (<u2> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u2> ^annotation empty)}
  (<a2> ^number singular)
-->
  (<a2> ^number singular +))

(sp chunk-10
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u1>)
  (<a4> ^{ <> <f2> <f1> } <f2>)
  (<u1> ^same-sense-sister <u1> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<o1> ^<f1> <f2>)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^left-edge <f1> ^word-id <f1> ^spec *empty* ^zero-head <u2>)
  (<u2> -^category c ^same-sense-sister <u2> ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u2> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u2> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<u1> ^annotation active + ^annotation active & ^annotation inactive -)
  (<u2> ^annotation active + ^annotation active & ^annotation inactive -))

(sp chunk-9
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^right-edge <f2> ^word-id <f2> -^word-id <f1> ^zero-head <u1>)
  (<a4> ^{ <> <f2> <f1> } <f2>)
  (<o1> ^<f1> <f2>)
  (<u1> ^agr <a1>)
  (<a1> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u2>)
  (<u2> -^category c ^annotation active ^agr <a2> ^sister <e1>)
 -{ (<u4> -^annotation trace)
    (<u2> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u2> ^annotation empty)}
  (<a2> ^number singular)
-->
  (<e1> ^annotation inactive + ^annotation inactive & ^annotation active -))

(sp chunk-8
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^right-edge <f2> ^word-id <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^{ <> <f2> <f1> } <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2> ^sister <e1>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<e1> ^annotation inactive + ^annotation inactive & ^annotation active -))

(sp chunk-7
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^<f1> <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<u3> ^spec <u4> + ^spec <u4> & ^spec *empty* -))

(sp chunk-6
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers2 <r1> ^receivers <r2> ^ordering-info <o1>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n6>)
  (<r1> ^n <n3>)
  (<n3> ^max <n4>)
  (<r2> ^n <n5>)
  (<n5> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^bar-level max ^word-id <f2> ^right-edge <f2> -^word-id <f1>
        ^zero-head <u2>)
  (<a4> ^<f1> <f2>)
  (<u2> ^category det ^agr <a2>)
  (<a2> ^number singular-plural)
  (<o1> ^<f1> <f2>)
  (<n6> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^word-id <f1> ^left-edge <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<n2> ^spec <u4> -)
  (<n4> ^spec <u4> -))

(sp chunk-5
  :chunk
  (goal <g1> ^state <s1> ^operator <o2>)
  (<s1> ^name initial-state ^assigners2 <a5> ^adjacency-info <a4>
        ^assigners <a3> ^receivers <r1> ^ordering-info <o1> ^receivers2 <r2>)
  (<o2> ^name u-constructor1 ^type u-model-constructor)
  (<a3> ^n <n3>)
  (<r1> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^word-id <f2> ^right-edge <f2> -^word-id <f1> ^zero-head <u2>)
  (<a4> ^{ <> <f2> <f1> } <f2>)
  (<o1> ^<f1> <f2>)
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u3> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u4>)}
  (<u3> ^left-edge <f1> ^word-id <f1> ^spec *empty* ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
 -{ (<u4> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u3>)}
 -{ (<u4> -^annotation trace)
    (<u1> ^annotation empty)}
  (<a1> ^number singular)
-->
  (<s1> ^receivers-ids <f2> -))

(sp chunk-4
  :chunk
  (goal <g1> ^state <s1> ^problem-space <p1>)
  (<s1> ^name initial-state ^assigners2 <a5> ^assigners <a4>
        ^adjacency-info <a3> ^ordering-info <o1> ^receivers <r1>
        ^receivers2 <r2>)
  (<p1> ^name u-construct)
  (<a4> ^n <n4>)
  (<n4> ^max <n2>)
  (<n2> ^spec <u4>)
  (<u4> ^spec *empty* ^word-id <f2> ^left-edge <f2> ^zero-head <u1>)
  (<u1> -^category c ^annotation active ^agr <a1>)
  (<a1> ^number singular)
  (<a3> ^<f2> <f1>)
  (<o1> ^<f2> <f1>)
  (<r1> ^n <n3>)
  (<n3> ^max <n1>)
  (<n1> ^spec { <> <u4> <u3> })
 -{ (<u4> ^snip-memory <sm>)
    (<sm> ^role spec ^receiver <u3>)}
  (<u3> -^word-id <f2> ^word-id <f1> ^right-edge <f1> ^zero-head <u2>)
 -{ (<u3> -^annotation trace)
    (<u1> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u4>)}
 -{ (<u3> -^annotation trace)
    (<u1> ^annotation empty)}
  (<u2> ^agr <a2>)
  (<a2> ^number singular-plural)
-->
  (<g1> ^operator <c1> +)
  (<c1> ^receiver <u3> + ^assigner <u4> + ^role spec + ^name link +
         ^annotation not-duplicate-relation &
         ^annotation not-duplicate-relation + ^agreements <a6> &
         ^agreements <a6> +)
  (<a6> ^number singular +))

(sp chunk-3
  :chunk
  (goal <g1> ^state <s1> ^operator <o2> ^operator <o2> + ^problem-space <p1>)
  (<s1> ^name generator-state ^ordering-info <o1> ^adjacency-info <a3>)
  (<o2> -^annotation constraints-passed ^constructed-operator <c1>)
  (<p1> ^name generator)
  (<c1> ^annotation not-duplicate-relation ^name link ^role spec
        ^assigner <u4> ^receiver <u3>)
  (<u4> ^zero-head <u2> ^word-id <f2>)
  (<u2> -^category c ^agr <a2>)
 -{ (<u3> -^annotation trace)
    (<u2> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u4>)}
 -{ (<u3> -^annotation trace)
    (<u2> ^annotation empty)}
  (<a2> ^number singular)
  (<u3> ^word-id <f1> ^zero-head <u1>)
  (<o1> ^<f2> <f1>)
  (<u1> ^agr <a1>)
  (<a1> ^number singular-plural)
-->
  (<c1> ^agreements <a4> + ^agreements <a4> &)
  (<a4> ^number singular +))

(sp chunk-2
  :chunk
  (goal <g1> ^state <s1> ^operator <o2> ^operator <o2> + ^problem-space <p1>)
  (<s1> ^name generator-state ^ordering-info <o1> ^adjacency-info <a3>)
  (<o2> -^annotation constraints-passed ^constructed-operator <c1>)
  (<p1> ^name generator)
  (<c1> ^annotation not-duplicate-relation ^name link ^role spec
        ^assigner <u4> ^receiver <u3>)
  (<u4> ^zero-head <u2> ^word-id <f2>)
  (<u2> -^category c ^agr <a2>)
 -{ (<u3> -^annotation trace)
    (<u2> ^category v ^downward-movement-projection <d*1>)
    (<d*1> ^comp <u4>)}
 -{ (<u3> -^annotation trace)
    (<u2> ^annotation empty)}
  (<a2> ^number singular)
  (<u3> ^word-id <f1> ^zero-head <u1>)
  (<o1> ^<f2> <f1>)
  (<u1> ^agr <a1>)
  (<a1> ^number singular-plural)
-->
  (<o2> ^annotation constraints-passed + ^annotation constraints-passed &))

(sp chunk-1
  :chunk
  (goal <g1> ^operator <o1> ^state <s1>)
  (<o1> ^name u-constructor1 ^type u-model-constructor)
-->
  (<s1> ^language-ops-allowed yes +))