Source file parser.ml

module MenhirBasics = struct
  
  exception Error
  
  let _eRR =
    fun _s ->
      raise Error
  
  type token = 
    | TIMES
    | ST
    | SQ
    | PLUS
    | PLB
    | NUM of 
# 10 "src/lp/parser.mly"
       (float)
# 20 "src/lp/parser.ml"
  
    | MLB
    | MINUS
    | MIN
    | MAX
    | LT
    | INF
    | ID of 
# 11 "src/lp/parser.mly"
       (string)
# 31 "src/lp/parser.ml"
  
    | GT
    | GENERAL
    | FREE
    | EQ
    | END
    | COLON
    | BOUND
    | BINARY
  
end

include MenhirBasics

# 1 "src/lp/parser.mly"
  
open Lpfile
module Cnstr = Constraint
let rev_poly tl = Poly.of_term_list (List.rev tl)
let rev_neg_head_poly tl = match List.rev tl with
    | hd :: rest -> Poly.of_term_list (Term.neg hd :: rest)
    | _-> failwith "empty polynomial expression"

# 55 "src/lp/parser.ml"

type ('s, 'r) _menhir_state = 
  | MenhirState01 : ('s, _menhir_box_sections) _menhir_state
    (** State 01.
        Stack shape : <empty>.
        Start symbol: sections. *)

  | MenhirState02 : (('s, _menhir_box_sections) _menhir_cell1_PLUS, _menhir_box_sections) _menhir_state
    (** State 02.
        Stack shape : PLUS.
        Start symbol: sections. *)

  | MenhirState14 : (('s, _menhir_box_sections) _menhir_cell1_poly_rev, _menhir_box_sections) _menhir_state
    (** State 14.
        Stack shape : poly_rev.
        Start symbol: sections. *)

  | MenhirState16 : (('s, _menhir_box_sections) _menhir_cell1_poly_rev, _menhir_box_sections) _menhir_state
    (** State 16.
        Stack shape : poly_rev.
        Start symbol: sections. *)

  | MenhirState18 : (('s, _menhir_box_sections) _menhir_cell1_PLB, _menhir_box_sections) _menhir_state
    (** State 18.
        Stack shape : PLB.
        Start symbol: sections. *)

  | MenhirState19 : (('s, _menhir_box_sections) _menhir_cell1_MINUS, _menhir_box_sections) _menhir_state
    (** State 19.
        Stack shape : MINUS.
        Start symbol: sections. *)

  | MenhirState23 : (('s, _menhir_box_sections) _menhir_cell1_MLB, _menhir_box_sections) _menhir_state
    (** State 23.
        Stack shape : MLB.
        Start symbol: sections. *)

  | MenhirState26 : (('s, _menhir_box_sections) _menhir_cell1_poly_in, _menhir_box_sections) _menhir_state
    (** State 26.
        Stack shape : poly_in.
        Start symbol: sections. *)

  | MenhirState28 : (('s, _menhir_box_sections) _menhir_cell1_poly_in, _menhir_box_sections) _menhir_state
    (** State 28.
        Stack shape : poly_in.
        Start symbol: sections. *)

  | MenhirState31 : ('s, _menhir_box_sections) _menhir_state
    (** State 31.
        Stack shape : <empty>.
        Start symbol: sections. *)

  | MenhirState35 : ('s _menhir_cell0_objective, _menhir_box_sections) _menhir_state
    (** State 35.
        Stack shape : objective.
        Start symbol: sections. *)

  | MenhirState37 : (('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_state
    (** State 37.
        Stack shape : ID.
        Start symbol: sections. *)

  | MenhirState39 : ((('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 39.
        Stack shape : ID poly.
        Start symbol: sections. *)

  | MenhirState47 : ((('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 47.
        Stack shape : ID poly.
        Start symbol: sections. *)

  | MenhirState49 : ((('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 49.
        Stack shape : ID poly.
        Start symbol: sections. *)

  | MenhirState52 : (('s, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 52.
        Stack shape : poly.
        Start symbol: sections. *)

  | MenhirState54 : (('s, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 54.
        Stack shape : poly.
        Start symbol: sections. *)

  | MenhirState56 : (('s, _menhir_box_sections) _menhir_cell1_poly, _menhir_box_sections) _menhir_state
    (** State 56.
        Stack shape : poly.
        Start symbol: sections. *)

  | MenhirState59 : (('s, _menhir_box_sections) _menhir_cell1_cnstr, _menhir_box_sections) _menhir_state
    (** State 59.
        Stack shape : cnstr.
        Start symbol: sections. *)

  | MenhirState62 : ('s _menhir_cell0_objective _menhir_cell0_cnstrs, _menhir_box_sections) _menhir_state
    (** State 62.
        Stack shape : objective cnstrs.
        Start symbol: sections. *)

  | MenhirState66 : (('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_state
    (** State 66.
        Stack shape : ID.
        Start symbol: sections. *)

  | MenhirState78 : (('s, _menhir_box_sections) _menhir_cell1_lower _menhir_cell0_ID, _menhir_box_sections) _menhir_state
    (** State 78.
        Stack shape : lower ID.
        Start symbol: sections. *)

  | MenhirState80 : (('s, _menhir_box_sections) _menhir_cell1_bound, _menhir_box_sections) _menhir_state
    (** State 80.
        Stack shape : bound.
        Start symbol: sections. *)

  | MenhirState82 : ('s _menhir_cell0_objective _menhir_cell0_cnstrs _menhir_cell0_bounds, _menhir_box_sections) _menhir_state
    (** State 82.
        Stack shape : objective cnstrs bounds.
        Start symbol: sections. *)

  | MenhirState83 : (('s, _menhir_box_sections) _menhir_cell1_GENERAL, _menhir_box_sections) _menhir_state
    (** State 83.
        Stack shape : GENERAL.
        Start symbol: sections. *)

  | MenhirState84 : (('s, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_state
    (** State 84.
        Stack shape : ID.
        Start symbol: sections. *)

  | MenhirState87 : (('s, _menhir_box_sections) _menhir_cell1_BINARY, _menhir_box_sections) _menhir_state
    (** State 87.
        Stack shape : BINARY.
        Start symbol: sections. *)

  | MenhirState91 : (('s, _menhir_box_sections) _menhir_cell1_vtype, _menhir_box_sections) _menhir_state
    (** State 91.
        Stack shape : vtype.
        Start symbol: sections. *)


and ('s, 'r) _menhir_cell1_bound = 
  | MenhirCell1_bound of 's * ('s, 'r) _menhir_state * (Lpfile.bound)

and 's _menhir_cell0_bounds = 
  | MenhirCell0_bounds of 's * (Lpfile.section list)

and ('s, 'r) _menhir_cell1_cnstr = 
  | MenhirCell1_cnstr of 's * ('s, 'r) _menhir_state * (Cnstr.t)

and 's _menhir_cell0_cnstrs = 
  | MenhirCell0_cnstrs of 's * (Lpfile.section list)

and ('s, 'r) _menhir_cell1_lower = 
  | MenhirCell1_lower of 's * ('s, 'r) _menhir_state * (float)

and 's _menhir_cell0_objective = 
  | MenhirCell0_objective of 's * (Lpfile.section list)

and ('s, 'r) _menhir_cell1_poly = 
  | MenhirCell1_poly of 's * ('s, 'r) _menhir_state * (Poly.t)

and ('s, 'r) _menhir_cell1_poly_in = 
  | MenhirCell1_poly_in of 's * ('s, 'r) _menhir_state * (Poly.t)

and ('s, 'r) _menhir_cell1_poly_rev = 
  | MenhirCell1_poly_rev of 's * ('s, 'r) _menhir_state * (Term.t list)

and ('s, 'r) _menhir_cell1_vtype = 
  | MenhirCell1_vtype of 's * ('s, 'r) _menhir_state * (Lpfile.section)

and ('s, 'r) _menhir_cell1_BINARY = 
  | MenhirCell1_BINARY of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_GENERAL = 
  | MenhirCell1_GENERAL of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_ID = 
  | MenhirCell1_ID of 's * ('s, 'r) _menhir_state * 
# 11 "src/lp/parser.mly"
       (string)
# 239 "src/lp/parser.ml"


and 's _menhir_cell0_ID = 
  | MenhirCell0_ID of 's * 
# 11 "src/lp/parser.mly"
       (string)
# 246 "src/lp/parser.ml"


and ('s, 'r) _menhir_cell1_MINUS = 
  | MenhirCell1_MINUS of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_MLB = 
  | MenhirCell1_MLB of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_PLB = 
  | MenhirCell1_PLB of 's * ('s, 'r) _menhir_state

and ('s, 'r) _menhir_cell1_PLUS = 
  | MenhirCell1_PLUS of 's * ('s, 'r) _menhir_state

and _menhir_box_sections = 
  | MenhirBox_sections of (Lpfile.t) [@@unboxed]

let _menhir_action_01 =
  fun v ->
    (
# 74 "src/lp/parser.mly"
                ( {name=v; lb=Float.neg_infinity; ub=Float.infinity} )
# 269 "src/lp/parser.ml"
     : (Lpfile.bound))

let _menhir_action_02 =
  fun lb v ->
    (
# 75 "src/lp/parser.mly"
                         ( {name=v; lb; ub=Float.infinity} )
# 277 "src/lp/parser.ml"
     : (Lpfile.bound))

let _menhir_action_03 =
  fun ub v ->
    (
# 76 "src/lp/parser.mly"
                         ( {name=v; lb=Float.zero; ub} )
# 285 "src/lp/parser.ml"
     : (Lpfile.bound))

let _menhir_action_04 =
  fun lb ub v ->
    (
# 77 "src/lp/parser.mly"
                                       ( {name=v; lb; ub} )
# 293 "src/lp/parser.ml"
     : (Lpfile.bound))

let _menhir_action_05 =
  fun () ->
    (
# 70 "src/lp/parser.mly"
              ( [] )
# 301 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_06 =
  fun l ->
    (
# 71 "src/lp/parser.mly"
                                   ( [Sbound l] )
# 309 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_07 =
  fun l p rhs ->
    (
# 33 "src/lp/parser.mly"
                                         ( Cnstr.eq ~name:l p rhs )
# 317 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_08 =
  fun l p rhs ->
    (
# 34 "src/lp/parser.mly"
                                         ( Cnstr.lt ~name:l p rhs )
# 325 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_09 =
  fun l p rhs ->
    (
# 35 "src/lp/parser.mly"
                                         ( Cnstr.gt ~name:l p rhs )
# 333 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_10 =
  fun p rhs ->
    (
# 36 "src/lp/parser.mly"
                            ( Cnstr.eq p rhs )
# 341 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_11 =
  fun p rhs ->
    (
# 37 "src/lp/parser.mly"
                            ( Cnstr.lt p rhs )
# 349 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_12 =
  fun p rhs ->
    (
# 38 "src/lp/parser.mly"
                            ( Cnstr.gt p rhs )
# 357 "src/lp/parser.ml"
     : (Cnstr.t))

let _menhir_action_13 =
  fun l ->
    (
# 30 "src/lp/parser.mly"
                              ( [Scnstr l] )
# 365 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_14 =
  fun n ->
    (
# 41 "src/lp/parser.mly"
             ( Poly.c n )
# 373 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_15 =
  fun () ->
    (
# 216 "<standard.mly>"
    ( [] )
# 381 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_16 =
  fun x xs ->
    (
# 219 "<standard.mly>"
    ( x :: xs )
# 389 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_17 =
  fun s ->
    (
# 80 "src/lp/parser.mly"
               ( s )
# 397 "src/lp/parser.ml"
     : (float))

let _menhir_action_18 =
  fun () ->
    (
# 81 "src/lp/parser.mly"
              ( Float.neg_infinity )
# 405 "src/lp/parser.ml"
     : (float))

let _menhir_action_19 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 413 "src/lp/parser.ml"
     : (string list))

let _menhir_action_20 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 421 "src/lp/parser.ml"
     : (string list))

let _menhir_action_21 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 429 "src/lp/parser.ml"
     : (Lpfile.bound list))

let _menhir_action_22 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 437 "src/lp/parser.ml"
     : (Lpfile.bound list))

let _menhir_action_23 =
  fun x ->
    (
# 228 "<standard.mly>"
    ( [ x ] )
# 445 "src/lp/parser.ml"
     : (Cnstr.t list))

let _menhir_action_24 =
  fun x xs ->
    (
# 231 "<standard.mly>"
    ( x :: xs )
# 453 "src/lp/parser.ml"
     : (Cnstr.t list))

let _menhir_action_25 =
  fun p ->
    (
# 26 "src/lp/parser.mly"
                 ( [Sobj (Objective.Min (Poly.half_quad p))] )
# 461 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_26 =
  fun p ->
    (
# 27 "src/lp/parser.mly"
                 ( [Sobj (Objective.Max (Poly.half_quad p))] )
# 469 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_action_27 =
  fun p ->
    (
# 44 "src/lp/parser.mly"
                ( p )
# 477 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_28 =
  fun p ->
    (
# 45 "src/lp/parser.mly"
                    ( p )
# 485 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_29 =
  fun p ->
    (
# 46 "src/lp/parser.mly"
                    ( Poly.neg p )
# 493 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_30 =
  fun p0 p1 ->
    (
# 47 "src/lp/parser.mly"
                                  ( Poly.(p0 ++ p1) )
# 501 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_31 =
  fun p0 p1 ->
    (
# 48 "src/lp/parser.mly"
                                  ( Poly.(p0 -- p1) )
# 509 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_32 =
  fun p ->
    (
# 51 "src/lp/parser.mly"
                 ( rev_poly p )
# 517 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_33 =
  fun p ->
    (
# 52 "src/lp/parser.mly"
                      ( rev_poly p )
# 525 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_34 =
  fun p ->
    (
# 53 "src/lp/parser.mly"
                       ( rev_neg_head_poly p )
# 533 "src/lp/parser.ml"
     : (Poly.t))

let _menhir_action_35 =
  fun t ->
    (
# 56 "src/lp/parser.mly"
             ( [t] )
# 541 "src/lp/parser.ml"
     : (Term.t list))

let _menhir_action_36 =
  fun p t ->
    (
# 57 "src/lp/parser.mly"
                                ( t :: p )
# 549 "src/lp/parser.ml"
     : (Term.t list))

let _menhir_action_37 =
  fun p t ->
    (
# 58 "src/lp/parser.mly"
                                ( Term.neg t :: p )
# 557 "src/lp/parser.ml"
     : (Term.t list))

let _menhir_action_38 =
  fun b c o v ->
    (
# 22 "src/lp/parser.mly"
    ( o @ c @ b @ v )
# 565 "src/lp/parser.ml"
     : (Lpfile.t))

let _menhir_action_39 =
  fun n ->
    (
# 89 "src/lp/parser.mly"
            ( n )
# 573 "src/lp/parser.ml"
     : (float))

let _menhir_action_40 =
  fun n ->
    (
# 90 "src/lp/parser.mly"
                 ( n )
# 581 "src/lp/parser.ml"
     : (float))

let _menhir_action_41 =
  fun n ->
    (
# 91 "src/lp/parser.mly"
                  ( Float.neg n )
# 589 "src/lp/parser.ml"
     : (float))

let _menhir_action_42 =
  fun n ->
    (
# 61 "src/lp/parser.mly"
            ( Term.Const n )
# 597 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_43 =
  fun v ->
    (
# 62 "src/lp/parser.mly"
           ( Term.Linear (Float.one, Var.make v) )
# 605 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_44 =
  fun n v ->
    (
# 63 "src/lp/parser.mly"
                    ( Term.Linear (n, Var.make v) )
# 613 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_45 =
  fun v0 v1 ->
    (
# 64 "src/lp/parser.mly"
                          ( Term.Quad (Float.one, Var.make v0, Var.make v1) )
# 621 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_46 =
  fun n v0 v1 ->
    (
# 65 "src/lp/parser.mly"
                                  ( Term.Quad (n, Var.make v0, Var.make v1) )
# 629 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_47 =
  fun v ->
    (
# 66 "src/lp/parser.mly"
              ( Term.Quad (Float.one, Var.make v, Var.make v) )
# 637 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_48 =
  fun n v ->
    (
# 67 "src/lp/parser.mly"
                       ( Term.Quad (n, Var.make v, Var.make v) )
# 645 "src/lp/parser.ml"
     : (Term.t))

let _menhir_action_49 =
  fun s ->
    (
# 84 "src/lp/parser.mly"
               ( s )
# 653 "src/lp/parser.ml"
     : (float))

let _menhir_action_50 =
  fun () ->
    (
# 85 "src/lp/parser.mly"
        ( Float.infinity )
# 661 "src/lp/parser.ml"
     : (float))

let _menhir_action_51 =
  fun () ->
    (
# 86 "src/lp/parser.mly"
             ( Float.infinity )
# 669 "src/lp/parser.ml"
     : (float))

let _menhir_action_52 =
  fun l ->
    (
# 97 "src/lp/parser.mly"
                                  ( Sgeneral l )
# 677 "src/lp/parser.ml"
     : (Lpfile.section))

let _menhir_action_53 =
  fun l ->
    (
# 98 "src/lp/parser.mly"
                                  ( Sbinary l )
# 685 "src/lp/parser.ml"
     : (Lpfile.section))

let _menhir_action_54 =
  fun l ->
    (
# 94 "src/lp/parser.mly"
                  ( l )
# 693 "src/lp/parser.ml"
     : (Lpfile.section list))

let _menhir_print_token : token -> string =
  fun _tok ->
    match _tok with
    | TIMES ->
        "TIMES"
    | ST ->
        "ST"
    | SQ ->
        "SQ"
    | PLUS ->
        "PLUS"
    | PLB ->
        "PLB"
    | NUM _ ->
        "NUM"
    | MLB ->
        "MLB"
    | MINUS ->
        "MINUS"
    | MIN ->
        "MIN"
    | MAX ->
        "MAX"
    | LT ->
        "LT"
    | INF ->
        "INF"
    | ID _ ->
        "ID"
    | GT ->
        "GT"
    | GENERAL ->
        "GENERAL"
    | FREE ->
        "FREE"
    | EQ ->
        "EQ"
    | END ->
        "END"
    | COLON ->
        "COLON"
    | BOUND ->
        "BOUND"
    | BINARY ->
        "BINARY"

let _menhir_fail : unit -> 'a =
  fun () ->
    Printf.eprintf "Internal failure -- please contact the parser generator's developers.\n%!";
    assert false

include struct
  
  [@@@ocaml.warning "-4-37"]
  
  let _menhir_run_93 : type  ttv_stack. ttv_stack _menhir_cell0_objective _menhir_cell0_cnstrs _menhir_cell0_bounds -> _ -> _menhir_box_sections =
    fun _menhir_stack _v ->
      let l = _v in
      let _v = _menhir_action_54 l in
      let MenhirCell0_bounds (_menhir_stack, b) = _menhir_stack in
      let MenhirCell0_cnstrs (_menhir_stack, c) = _menhir_stack in
      let MenhirCell0_objective (_menhir_stack, o) = _menhir_stack in
      let v = _v in
      let _v = _menhir_action_38 b c o v in
      MenhirBox_sections _v
  
  let rec _menhir_run_92 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_vtype -> _ -> _menhir_box_sections =
    fun _menhir_stack _v ->
      let MenhirCell1_vtype (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_16 x xs in
      _menhir_goto_list_vtype_ _menhir_stack _v _menhir_s
  
  and _menhir_goto_list_vtype_ : type  ttv_stack. ttv_stack -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _v _menhir_s ->
      match _menhir_s with
      | MenhirState91 ->
          _menhir_run_92 _menhir_stack _v
      | MenhirState82 ->
          _menhir_run_93 _menhir_stack _v
      | _ ->
          _menhir_fail ()
  
  let rec _menhir_run_83 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_GENERAL (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState83 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_84 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_84 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          _menhir_run_84 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState84
      | BINARY | END | GENERAL ->
          let x = _v in
          let _v = _menhir_action_19 x in
          _menhir_goto_nonempty_list_ID_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_ID_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState84 ->
          _menhir_run_85 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState83 ->
          _menhir_run_86 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState87 ->
          _menhir_run_88 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_85 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_20 x xs in
      _menhir_goto_nonempty_list_ID_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_86 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_GENERAL -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_GENERAL (_menhir_stack, _menhir_s) = _menhir_stack in
      let l = _v in
      let _v = _menhir_action_52 l in
      _menhir_goto_vtype _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_vtype : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_vtype (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | GENERAL ->
          _menhir_run_83 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState91
      | BINARY ->
          _menhir_run_87 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState91
      | END ->
          let _v_0 = _menhir_action_15 () in
          _menhir_run_92 _menhir_stack _v_0
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_87 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_BINARY (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState87 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          _menhir_run_84 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_88 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_BINARY -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_BINARY (_menhir_stack, _menhir_s) = _menhir_stack in
      let l = _v in
      let _v = _menhir_action_53 l in
      _menhir_goto_vtype _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_goto_bounds : type  ttv_stack. ttv_stack _menhir_cell0_objective _menhir_cell0_cnstrs -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_bounds (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | GENERAL ->
          _menhir_run_83 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState82
      | BINARY ->
          _menhir_run_87 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState82
      | END ->
          let _v_0 = _menhir_action_15 () in
          _menhir_run_93 _menhir_stack _v_0
      | _ ->
          _menhir_fail ()
  
  let _menhir_run_74 : type  ttv_stack. ttv_stack _menhir_cell0_objective _menhir_cell0_cnstrs -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let l = _v in
      let _v = _menhir_action_06 l in
      _menhir_goto_bounds _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  let rec _menhir_goto_nonempty_list_bound_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState62 ->
          _menhir_run_74 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState80 ->
          _menhir_run_81 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_81 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_bound -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_bound (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_22 x xs in
      _menhir_goto_nonempty_list_bound_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let rec _menhir_run_02 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_PLUS (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState02 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_03 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v_0 ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | TIMES ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | ID _v_1 ->
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  let (n, v1, v0) = (_v, _v_1, _v_0) in
                  let _v = _menhir_action_46 n v0 v1 in
                  _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | SQ ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              let (n, v) = (_v, _v_0) in
              let _v = _menhir_action_48 n v in
              _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | EQ | GT | LT | MINUS | MLB | PLB | PLUS | ST ->
              let (n, v) = (_v, _v_0) in
              let _v = _menhir_action_44 n v in
              _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
          | _ ->
              _eRR ())
      | EQ | GT | LT | MINUS | MLB | PLB | PLUS | ST ->
          let n = _v in
          let _v = _menhir_action_42 n in
          _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_term : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState01 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState02 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState18 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState23 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState26 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState28 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState59 ->
          _menhir_run_12 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState14 ->
          _menhir_run_15 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState16 ->
          _menhir_run_17 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_12 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let t = _v in
      let _v = _menhir_action_35 t in
      _menhir_goto_poly_rev _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_poly_rev : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState02 ->
          _menhir_run_13 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState19 ->
          _menhir_run_20 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState01 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState18 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState23 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState26 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState28 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState59 ->
          _menhir_run_21 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_13 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_PLUS as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer
      | MINUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQ | GT | LT | MLB | PLB | ST ->
          let MenhirCell1_PLUS (_menhir_stack, _menhir_s) = _menhir_stack in
          let p = _v in
          let _v = _menhir_action_33 p in
          _menhir_goto_poly_in _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_14 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_rev -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState14 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_08 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TIMES ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer
      | SQ ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQ | GT | LT | MINUS | MLB | PLB | PLUS | ST ->
          let v = _v in
          let _v = _menhir_action_43 v in
          _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_09 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_ID -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | ID _v ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let MenhirCell1_ID (_menhir_stack, _menhir_s, v0) = _menhir_stack in
          let v1 = _v in
          let _v = _menhir_action_45 v0 v1 in
          _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_11 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_ID -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_ID (_menhir_stack, _menhir_s, v) = _menhir_stack in
      let _v = _menhir_action_47 v in
      _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_16 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_rev -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _menhir_s = MenhirState16 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_goto_poly_in : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState18 ->
          _menhir_run_22 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState23 ->
          _menhir_run_24 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState01 ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState31 ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState37 ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState59 ->
          _menhir_run_25 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState26 ->
          _menhir_run_27 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState28 ->
          _menhir_run_29 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_22 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_PLB -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_PLB (_menhir_stack, _menhir_s) = _menhir_stack in
      let p = _v in
      let _v = _menhir_action_28 p in
      _menhir_goto_poly _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_poly : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState01 ->
          _menhir_run_30 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState31 ->
          _menhir_run_32 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState37 ->
          _menhir_run_38 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState35 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState59 ->
          _menhir_run_51 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_30 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let p = _v in
      let _v = _menhir_action_25 p in
      _menhir_goto_objective _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_goto_objective : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let _menhir_stack = MenhirCell0_objective (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | ST ->
          let _menhir_s = MenhirState35 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PLB ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MLB ->
              _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_18 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_PLB (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState18 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MINUS ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_19 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MINUS (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState19 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_23 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MLB (_menhir_stack, _menhir_s) in
      let _menhir_s = MenhirState23 in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | NUM _v ->
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | MINUS ->
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
      | ID _v ->
          _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
      | _ ->
          _eRR ()
  
  and _menhir_run_36 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | TIMES ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          _menhir_run_09 _menhir_stack _menhir_lexbuf _menhir_lexer
      | SQ ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          _menhir_run_11 _menhir_stack _menhir_lexbuf _menhir_lexer
      | COLON ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState37 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PLB ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MLB ->
              _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | EQ | GT | LT | MINUS | MLB | PLB | PLUS ->
          let v = _v in
          let _v = _menhir_action_43 v in
          _menhir_goto_term _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_32 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let p = _v in
      let _v = _menhir_action_26 p in
      _menhir_goto_objective _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
  
  and _menhir_run_38 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_ID as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_poly (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LT ->
          let _menhir_s = MenhirState39 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | GT ->
          let _menhir_s = MenhirState47 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | EQ ->
          let _menhir_s = MenhirState49 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_40 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_PLUS (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_41 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_PLUS -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_PLUS (_menhir_stack, _menhir_s) = _menhir_stack in
      let n = _v in
      let _v = _menhir_action_40 n in
      _menhir_goto_signed _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_signed : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState39 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState47 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState49 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState52 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState54 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState56 ->
          _menhir_run_45 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState66 ->
          _menhir_run_71 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState78 ->
          _menhir_run_71 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState62 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | MenhirState80 ->
          _menhir_run_73 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_45 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let n = _v in
      let _v = _menhir_action_14 n in
      _menhir_goto_const _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_const : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState39 ->
          _menhir_run_46 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState47 ->
          _menhir_run_48 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState49 ->
          _menhir_run_50 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState52 ->
          _menhir_run_53 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState54 ->
          _menhir_run_55 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState56 ->
          _menhir_run_57 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_46 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _, p) = _menhir_stack in
      let MenhirCell1_ID (_menhir_stack, _menhir_s, l) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_08 l p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_cnstr : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | PLB ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | NUM _v_0 ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState59
      | MLB ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | MINUS ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState59
      | ID _v_1 ->
          let _menhir_stack = MenhirCell1_cnstr (_menhir_stack, _menhir_s, _v) in
          _menhir_run_36 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState59
      | BINARY | BOUND | END | GENERAL ->
          let x = _v in
          let _v = _menhir_action_23 x in
          _menhir_goto_nonempty_list_cnstr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_nonempty_list_cnstr_ : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState35 ->
          _menhir_run_58 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState59 ->
          _menhir_run_60 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_58 : type  ttv_stack. ttv_stack _menhir_cell0_objective -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let l = _v in
      let _v = _menhir_action_13 l in
      let _menhir_stack = MenhirCell0_cnstrs (_menhir_stack, _v) in
      match (_tok : MenhirBasics.token) with
      | BOUND ->
          let _menhir_s = MenhirState62 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_65 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | BINARY | END | GENERAL ->
          let _v = _menhir_action_05 () in
          _menhir_goto_bounds _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_42 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let n = _v in
      let _v = _menhir_action_39 n in
      _menhir_goto_signed _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_63 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          let _menhir_stack = MenhirCell1_MINUS (_menhir_stack, _menhir_s) in
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | INF ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_18 () in
          _menhir_goto_lower _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_44 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_MINUS -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let MenhirCell1_MINUS (_menhir_stack, _menhir_s) = _menhir_stack in
      let n = _v in
      let _v = _menhir_action_41 n in
      _menhir_goto_signed _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_lower : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | LT ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | ID _v_0 ->
              let _tok = _menhir_lexer _menhir_lexbuf in
              (match (_tok : MenhirBasics.token) with
              | LT ->
                  let _menhir_stack = MenhirCell1_lower (_menhir_stack, _menhir_s, _v) in
                  let _menhir_stack = MenhirCell0_ID (_menhir_stack, _v_0) in
                  let _menhir_s = MenhirState78 in
                  let _tok = _menhir_lexer _menhir_lexbuf in
                  (match (_tok : MenhirBasics.token) with
                  | PLUS ->
                      _menhir_run_67 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | NUM _v ->
                      _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
                  | MINUS ->
                      _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | INF ->
                      _menhir_run_69 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
                  | _ ->
                      _eRR ())
              | BINARY | END | GENERAL | ID _ | MINUS | NUM _ | PLUS ->
                  let (v, lb) = (_v_0, _v) in
                  let _v = _menhir_action_02 lb v in
                  _menhir_goto_bound _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
              | _ ->
                  _eRR ())
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_67 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          let _menhir_stack = MenhirCell1_PLUS (_menhir_stack, _menhir_s) in
          _menhir_run_41 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | INF ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let _v = _menhir_action_51 () in
          _menhir_goto_upper _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_goto_upper : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match _menhir_s with
      | MenhirState66 ->
          _menhir_run_70 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | MenhirState78 ->
          _menhir_run_79 _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_70 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_ID -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_ID (_menhir_stack, _menhir_s, v) = _menhir_stack in
      let ub = _v in
      let _v = _menhir_action_03 ub v in
      _menhir_goto_bound _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_goto_bound : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          let _menhir_stack = MenhirCell1_bound (_menhir_stack, _menhir_s, _v) in
          _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState80
      | NUM _v_0 ->
          let _menhir_stack = MenhirCell1_bound (_menhir_stack, _menhir_s, _v) in
          _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v_0 MenhirState80
      | MINUS ->
          let _menhir_stack = MenhirCell1_bound (_menhir_stack, _menhir_s, _v) in
          _menhir_run_63 _menhir_stack _menhir_lexbuf _menhir_lexer MenhirState80
      | ID _v_1 ->
          let _menhir_stack = MenhirCell1_bound (_menhir_stack, _menhir_s, _v) in
          _menhir_run_65 _menhir_stack _menhir_lexbuf _menhir_lexer _v_1 MenhirState80
      | BINARY | END | GENERAL ->
          let x = _v in
          let _v = _menhir_action_21 x in
          _menhir_goto_nonempty_list_bound_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_65 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | LT ->
          let _menhir_stack = MenhirCell1_ID (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState66 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_67 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | INF ->
              _menhir_run_69 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | FREE ->
          let _tok = _menhir_lexer _menhir_lexbuf in
          let v = _v in
          let _v = _menhir_action_01 v in
          _menhir_goto_bound _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_43 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _menhir_stack = MenhirCell1_MINUS (_menhir_stack, _menhir_s) in
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | NUM _v ->
          _menhir_run_44 _menhir_stack _menhir_lexbuf _menhir_lexer _v
      | _ ->
          _eRR ()
  
  and _menhir_run_69 : type  ttv_stack. ttv_stack -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      let _v = _menhir_action_50 () in
      _menhir_goto_upper _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_79 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_lower _menhir_cell0_ID -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell0_ID (_menhir_stack, v) = _menhir_stack in
      let MenhirCell1_lower (_menhir_stack, _menhir_s, lb) = _menhir_stack in
      let ub = _v in
      let _v = _menhir_action_04 lb ub v in
      _menhir_goto_bound _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_60 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_cnstr -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_cnstr (_menhir_stack, _menhir_s, x) = _menhir_stack in
      let xs = _v in
      let _v = _menhir_action_24 x xs in
      _menhir_goto_nonempty_list_cnstr_ _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_48 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _, p) = _menhir_stack in
      let MenhirCell1_ID (_menhir_stack, _menhir_s, l) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_09 l p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_50 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_ID, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _, p) = _menhir_stack in
      let MenhirCell1_ID (_menhir_stack, _menhir_s, l) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_07 l p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_53 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_11 p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_55 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_12 p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_57 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let rhs = _v in
      let _v = _menhir_action_10 p rhs in
      _menhir_goto_cnstr _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_71 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let s = _v in
      let _v = _menhir_action_49 s in
      _menhir_goto_upper _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_73 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let s = _v in
      let _v = _menhir_action_17 s in
      _menhir_goto_lower _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_51 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      let _menhir_stack = MenhirCell1_poly (_menhir_stack, _menhir_s, _v) in
      match (_tok : MenhirBasics.token) with
      | LT ->
          let _menhir_s = MenhirState52 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | GT ->
          let _menhir_s = MenhirState54 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | EQ ->
          let _menhir_s = MenhirState56 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_40 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_42 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_43 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
  and _menhir_run_24 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_MLB -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_MLB (_menhir_stack, _menhir_s) = _menhir_stack in
      let p = _v in
      let _v = _menhir_action_29 p in
      _menhir_goto_poly _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_25 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLB ->
          let _menhir_stack = MenhirCell1_poly_in (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState26 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | MLB ->
          let _menhir_stack = MenhirCell1_poly_in (_menhir_stack, _menhir_s, _v) in
          let _menhir_s = MenhirState28 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | EQ | GT | LT | ST ->
          let p = _v in
          let _v = _menhir_action_27 p in
          _menhir_goto_poly _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _menhir_fail ()
  
  and _menhir_run_27 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_in -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly_in (_menhir_stack, _menhir_s, p0) = _menhir_stack in
      let p1 = _v in
      let _v = _menhir_action_30 p0 p1 in
      _menhir_goto_poly _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_29 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_in -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly_in (_menhir_stack, _menhir_s, p0) = _menhir_stack in
      let p1 = _v in
      let _v = _menhir_action_31 p0 p1 in
      _menhir_goto_poly _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_20 : type  ttv_stack. ((ttv_stack, _menhir_box_sections) _menhir_cell1_MINUS as 'stack) -> _ -> _ -> _ -> ('stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer
      | MINUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQ | GT | LT | MLB | PLB | ST ->
          let MenhirCell1_MINUS (_menhir_stack, _menhir_s) = _menhir_stack in
          let p = _v in
          let _v = _menhir_action_34 p in
          _menhir_goto_poly_in _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_21 : type  ttv_stack. ttv_stack -> _ -> _ -> _ -> (ttv_stack, _menhir_box_sections) _menhir_state -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok ->
      match (_tok : MenhirBasics.token) with
      | PLUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_14 _menhir_stack _menhir_lexbuf _menhir_lexer
      | MINUS ->
          let _menhir_stack = MenhirCell1_poly_rev (_menhir_stack, _menhir_s, _v) in
          _menhir_run_16 _menhir_stack _menhir_lexbuf _menhir_lexer
      | EQ | GT | LT | MLB | PLB | ST ->
          let p = _v in
          let _v = _menhir_action_32 p in
          _menhir_goto_poly_in _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
      | _ ->
          _eRR ()
  
  and _menhir_run_15 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_rev -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly_rev (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_36 p t in
      _menhir_goto_poly_rev _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  and _menhir_run_17 : type  ttv_stack. (ttv_stack, _menhir_box_sections) _menhir_cell1_poly_rev -> _ -> _ -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer _v _tok ->
      let MenhirCell1_poly_rev (_menhir_stack, _menhir_s, p) = _menhir_stack in
      let t = _v in
      let _v = _menhir_action_37 p t in
      _menhir_goto_poly_rev _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s _tok
  
  let _menhir_run_00 : type  ttv_stack. ttv_stack -> _ -> _ -> _menhir_box_sections =
    fun _menhir_stack _menhir_lexbuf _menhir_lexer ->
      let _tok = _menhir_lexer _menhir_lexbuf in
      match (_tok : MenhirBasics.token) with
      | MIN ->
          let _menhir_s = MenhirState01 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PLB ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MLB ->
              _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | MAX ->
          let _menhir_s = MenhirState31 in
          let _tok = _menhir_lexer _menhir_lexbuf in
          (match (_tok : MenhirBasics.token) with
          | PLUS ->
              _menhir_run_02 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | PLB ->
              _menhir_run_18 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | NUM _v ->
              _menhir_run_03 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | MLB ->
              _menhir_run_23 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | MINUS ->
              _menhir_run_19 _menhir_stack _menhir_lexbuf _menhir_lexer _menhir_s
          | ID _v ->
              _menhir_run_08 _menhir_stack _menhir_lexbuf _menhir_lexer _v _menhir_s
          | _ ->
              _eRR ())
      | _ ->
          _eRR ()
  
end

let sections =
  fun _menhir_lexer _menhir_lexbuf ->
    let _menhir_stack = () in
    let MenhirBox_sections v = _menhir_run_00 _menhir_stack _menhir_lexbuf _menhir_lexer in
    v