functor OclParserLrValsFun(structure Token : TOKEN)
 : sig structure ParserData : PARSER_DATA
       structure Tokens : OclParser_TOKENS
   end
 = 
struct
structure ParserData=
struct
structure Header = 
struct
(*****************************************************************************
 * su4sml --- a SML repository for managing (Secure)UML/OCL models
 *             http://projects.brucker.ch/su4sml/
 *                                                                            
 * ocl.grm --- 
 * This file is part of su4sml.
 *
 * Copyright (c) 2005-2007, ETH Zurich, Switzerland
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *
 *     * Neither the name of the copyright holders nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ******************************************************************************)
(* $Id$ *)

(* 

THIS POINTS HAVE TO BE NOTICED TO UNDERSTAND THE SEMANTICS OF:

         - context_declarations.sml
         - type_checker.sml


 i.)    'AttributeCall' needs a path for the name of the attriubte.
        But it is not possible to extract the hole name when 'AttributeCall' is constructed.
        So, we only have a 'Path' with one element, the name of the attribute.
        But the type still is 'Path' because of the types.

 ii.)   We cannot know if a 'propertycall_exp_cs' is a member of a Class or a Variable of the signature.
        Therefore, all calls to Variables from signature are parsed as 'AttributeCall's



*)


open Rep_Core
open Rep_OclTerm
open Rep_OclType
open XMI_DataTypes

open Context

type Visibility = Rep_Core.Visibility
type Scope      = XMI_DataTypes.ScopeKind

exception NotYetSupported of string 



end
structure LrTable = Token.LrTable
structure Token = Token
local open LrTable in 
val table=let val actionRows =
"\
\\001\000\001\000\000\000\000\000\
\\001\000\003\000\217\000\079\000\014\000\000\000\
\\001\000\007\000\069\000\027\000\068\000\039\000\067\000\045\000\066\000\
\\050\000\065\000\000\000\
\\001\000\007\000\091\000\079\000\014\000\000\000\
\\001\000\007\000\096\000\079\000\014\000\000\000\
\\001\000\007\000\098\000\079\000\014\000\000\000\
\\001\000\007\000\111\000\000\000\
\\001\000\007\000\111\000\045\000\066\000\000\000\
\\001\000\007\000\115\000\079\000\014\000\000\000\
\\001\000\007\000\117\000\000\000\
\\001\000\007\000\154\000\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\001\000\007\000\155\000\000\000\
\\001\000\007\000\157\000\000\000\
\\001\000\007\000\171\000\000\000\
\\001\000\007\000\228\000\000\000\
\\001\000\007\000\229\000\000\000\
\\001\000\009\000\046\001\000\000\
\\001\000\010\000\224\000\000\000\
\\001\000\010\000\005\001\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\046\000\000\001\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\046\000\033\001\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\048\000\249\000\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\062\000\143\000\075\000\142\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\040\000\145\000\045\000\144\000\
\\051\000\031\000\052\000\030\000\053\000\029\000\054\000\028\000\
\\055\000\027\000\056\000\026\000\057\000\025\000\058\000\024\000\
\\059\000\023\000\060\000\022\000\061\000\021\000\062\000\143\000\
\\075\000\142\000\076\000\141\000\077\000\140\000\078\000\139\000\
\\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\045\000\144\000\051\000\031\000\
\\052\000\030\000\053\000\029\000\054\000\028\000\055\000\027\000\
\\056\000\026\000\057\000\025\000\058\000\024\000\059\000\023\000\
\\060\000\022\000\061\000\021\000\062\000\143\000\075\000\142\000\
\\076\000\141\000\077\000\140\000\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\032\000\149\000\033\000\148\000\034\000\032\000\
\\035\000\147\000\036\000\146\000\045\000\144\000\051\000\031\000\
\\052\000\030\000\053\000\029\000\054\000\028\000\055\000\027\000\
\\056\000\026\000\057\000\025\000\058\000\024\000\059\000\023\000\
\\060\000\022\000\061\000\021\000\076\000\141\000\077\000\140\000\
\\078\000\139\000\079\000\014\000\000\000\
\\001\000\014\000\108\000\015\000\107\000\016\000\106\000\017\000\105\000\
\\018\000\104\000\079\000\014\000\000\000\
\\001\000\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\001\000\026\000\046\000\031\000\045\000\000\000\
\\001\000\027\000\068\000\039\000\067\000\000\000\
\\001\000\028\000\168\000\038\000\167\000\000\000\
\\001\000\029\000\040\001\000\000\
\\001\000\030\000\050\001\000\000\
\\001\000\031\000\051\000\000\000\
\\001\000\034\000\032\000\051\000\031\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\059\000\023\000\060\000\022\000\061\000\021\000\
\\079\000\014\000\000\000\
\\001\000\034\000\032\000\051\000\237\000\052\000\030\000\053\000\029\000\
\\054\000\028\000\055\000\027\000\056\000\026\000\057\000\025\000\
\\058\000\024\000\079\000\014\000\000\000\
\\001\000\037\000\003\001\000\000\
\\001\000\041\000\008\000\080\000\007\000\000\000\
\\001\000\044\000\007\001\000\000\
\\001\000\045\000\113\000\000\000\
\\001\000\045\000\164\000\000\000\
\\001\000\045\000\014\001\000\000\
\\001\000\045\000\015\001\000\000\
\\001\000\045\000\016\001\000\000\
\\001\000\046\000\094\000\079\000\014\000\000\000\
\\001\000\046\000\150\000\000\000\
\\001\000\046\000\230\000\000\000\
\\001\000\046\000\001\001\000\000\
\\001\000\046\000\009\001\000\000\
\\001\000\046\000\024\001\000\000\
\\001\000\046\000\042\001\000\000\
\\001\000\046\000\044\001\000\000\
\\001\000\046\000\048\001\000\000\
\\001\000\046\000\052\001\000\000\
\\001\000\047\000\204\000\000\000\
\\001\000\048\000\020\001\000\000\
\\001\000\049\000\043\001\000\000\
\\001\000\049\000\049\001\000\000\
\\001\000\079\000\014\000\000\000\
\\001\000\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\001\000\085\000\033\000\000\000\
\\001\000\087\000\036\000\000\000\
\\054\001\000\000\
\\055\001\080\000\007\000\000\000\
\\056\001\041\000\008\000\000\000\
\\057\001\000\000\
\\058\001\000\000\
\\059\001\041\000\008\000\000\000\
\\060\001\000\000\
\\061\001\000\000\
\\062\001\000\000\
\\063\001\026\000\046\000\000\000\
\\064\001\000\000\
\\065\001\000\000\
\\066\001\000\000\
\\067\001\000\000\
\\068\001\000\000\
\\069\001\000\000\
\\070\001\000\000\
\\071\001\000\000\
\\072\001\000\000\
\\073\001\000\000\
\\074\001\028\000\168\000\038\000\167\000\000\000\
\\075\001\000\000\
\\076\001\027\000\068\000\039\000\067\000\000\000\
\\077\001\000\000\
\\078\001\025\000\088\000\042\000\087\000\043\000\086\000\000\000\
\\079\001\000\000\
\\080\001\050\000\065\000\000\000\
\\081\001\000\000\
\\082\001\000\000\
\\083\001\000\000\
\\084\001\000\000\
\\085\001\000\000\
\\086\001\000\000\
\\087\001\000\000\
\\088\001\000\000\
\\089\001\000\000\
\\090\001\000\000\
\\091\001\000\000\
\\092\001\000\000\
\\093\001\000\000\
\\094\001\000\000\
\\095\001\000\000\
\\096\001\000\000\
\\097\001\007\000\154\000\000\000\
\\098\001\000\000\
\\099\001\007\000\154\000\000\000\
\\100\001\000\000\
\\101\001\000\000\
\\102\001\000\000\
\\103\001\000\000\
\\104\001\000\000\
\\105\001\000\000\
\\106\001\000\000\
\\107\001\003\000\019\001\000\000\
\\108\001\000\000\
\\109\001\000\000\
\\110\001\000\000\
\\111\001\006\000\017\001\000\000\
\\112\001\000\000\
\\113\001\000\000\
\\114\001\000\000\
\\115\001\000\000\
\\116\001\000\000\
\\117\001\000\000\
\\118\001\000\000\
\\119\001\000\000\
\\120\001\000\000\
\\121\001\000\000\
\\122\001\000\000\
\\123\001\000\000\
\\124\001\000\000\
\\125\001\000\000\
\\126\001\000\000\
\\127\001\000\000\
\\128\001\000\000\
\\129\001\000\000\
\\130\001\000\000\
\\131\001\000\000\
\\132\001\000\000\
\\133\001\000\000\
\\134\001\000\000\
\\135\001\000\000\
\\136\001\008\000\037\000\000\000\
\\137\001\008\000\049\000\000\000\
\\138\001\000\000\
\\138\001\007\000\111\000\000\000\
\\139\001\000\000\
\\140\001\000\000\
\\141\001\000\000\
\\142\001\000\000\
\\143\001\000\000\
\\144\001\000\000\
\\145\001\000\000\
\\146\001\000\000\
\\147\001\000\000\
\\148\001\000\000\
\\149\001\000\000\
\\150\001\000\000\
\\151\001\000\000\
\\152\001\000\000\
\\153\001\000\000\
\\154\001\000\000\
\\155\001\000\000\
\\156\001\071\000\203\000\072\000\202\000\073\000\201\000\074\000\200\000\000\000\
\\157\001\000\000\
\\158\001\071\000\203\000\072\000\202\000\073\000\201\000\074\000\200\000\000\000\
\\159\001\000\000\
\\160\001\000\000\
\\161\001\000\000\
\\162\001\000\000\
\\163\001\000\000\
\\164\001\000\000\
\\165\001\010\000\196\000\066\000\195\000\067\000\194\000\068\000\193\000\
\\069\000\192\000\070\000\191\000\000\000\
\\166\001\000\000\
\\167\001\000\000\
\\168\001\000\000\
\\169\001\000\000\
\\170\001\000\000\
\\171\001\000\000\
\\172\001\000\000\
\\173\001\000\000\
\\174\001\062\000\188\000\065\000\187\000\000\000\
\\175\001\000\000\
\\176\001\062\000\188\000\065\000\187\000\000\000\
\\177\001\000\000\
\\178\001\000\000\
\\179\001\000\000\
\\180\001\000\000\
\\181\001\063\000\183\000\064\000\182\000\000\000\
\\182\001\000\000\
\\183\001\063\000\183\000\064\000\182\000\000\000\
\\184\001\000\000\
\\185\001\000\000\
\\186\001\000\000\
\\187\001\000\000\
\\188\001\000\000\
\\189\001\000\000\
\\190\001\000\000\
\\191\001\000\000\
\\192\001\004\000\177\000\005\000\176\000\000\000\
\\193\001\000\000\
\\194\001\000\000\
\\195\001\000\000\
\\196\001\000\000\
\\197\001\000\000\
\\198\001\000\000\
\\199\001\004\000\177\000\005\000\176\000\000\000\
\\200\001\000\000\
\\201\001\000\000\
\\202\001\000\000\
\\203\001\013\000\209\000\045\000\208\000\000\000\
\\204\001\045\000\208\000\000\000\
\\205\001\000\000\
\\206\001\000\000\
\\207\001\000\000\
\\208\001\000\000\
\\209\001\000\000\
\\210\001\000\000\
\\211\001\000\000\
\\212\001\000\000\
\\213\001\000\000\
\\215\001\000\000\
\\216\001\000\000\
\\217\001\003\000\023\001\000\000\
\\218\001\000\000\
\\219\001\003\000\023\001\000\000\
\\220\001\000\000\
\\221\001\000\000\
\\222\001\000\000\
\\223\001\000\000\
\\224\001\003\000\152\000\000\000\
\\225\001\000\000\
\\226\001\000\000\
\\227\001\000\000\
\\228\001\000\000\
\\229\001\000\000\
\\230\001\000\000\
\\231\001\000\000\
\\232\001\000\000\
\\233\001\000\000\
\\234\001\003\000\217\000\000\000\
\\235\001\000\000\
\\236\001\000\000\
\\237\001\000\000\
\\239\001\000\000\
\\243\001\000\000\
\\244\001\000\000\
\\245\001\087\000\036\000\000\000\
\\246\001\000\000\
\\247\001\000\000\
\\248\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\249\001\000\000\
\\250\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\251\001\000\000\
\\252\001\081\000\059\000\082\000\058\000\086\000\057\000\000\000\
\\253\001\000\000\
\\254\001\000\000\
\\255\001\079\000\014\000\000\000\
\\000\002\000\000\
\\001\002\000\000\
\\002\002\000\000\
\\003\002\000\000\
\\004\002\079\000\014\000\000\000\
\\005\002\000\000\
\\006\002\000\000\
\\007\002\000\000\
\\008\002\000\000\
\"
val actionRowNumbers =
"\036\000\063\000\066\000\062\000\
\\061\000\057\000\033\000\065\000\
\\067\000\064\000\059\000\060\000\
\\077\000\149\000\148\000\143\000\
\\145\000\033\000\027\000\142\000\
\\140\000\141\000\139\000\138\000\
\\136\000\137\000\134\000\133\000\
\\132\000\147\000\135\000\246\000\
\\248\000\247\000\057\000\150\000\
\\144\000\075\000\074\000\073\000\
\\072\000\070\000\032\000\068\000\
\\033\000\249\000\058\000\151\000\
\\071\000\069\000\002\000\255\000\
\\253\000\251\000\250\000\028\000\
\\057\000\057\000\087\000\080\000\
\\026\000\083\000\078\000\003\000\
\\043\000\004\000\005\000\025\000\
\\000\001\254\000\252\000\010\001\
\\011\001\006\001\007\001\009\001\
\\006\000\001\001\002\001\038\000\
\\088\000\008\000\085\000\079\000\
\\110\000\109\000\111\000\084\000\
\\009\000\022\000\044\000\231\000\
\\104\000\011\000\022\000\012\000\
\\057\000\236\000\237\000\039\000\
\\238\000\029\000\121\000\125\000\
\\123\000\124\000\122\000\008\001\
\\234\000\025\000\003\001\057\000\
\\013\000\022\000\086\000\022\000\
\\204\000\200\000\197\000\024\000\
\\189\000\182\000\173\000\164\000\
\\128\000\157\000\156\000\155\000\
\\154\000\152\000\153\000\202\000\
\\129\000\097\000\205\000\053\000\
\\211\000\160\000\159\000\158\000\
\\199\000\198\000\022\000\001\000\
\\023\000\161\000\163\000\162\000\
\\106\000\232\000\057\000\105\000\
\\025\000\022\000\091\000\057\000\
\\102\000\101\000\100\000\017\000\
\\093\000\007\000\025\000\081\000\
\\076\000\014\000\015\000\235\000\
\\045\000\022\000\095\000\098\000\
\\207\000\201\000\033\000\034\000\
\\196\000\023\000\191\000\190\000\
\\195\000\194\000\023\000\183\000\
\\184\000\187\000\188\000\023\000\
\\174\000\180\000\179\000\178\000\
\\177\000\181\000\176\000\165\000\
\\023\000\166\000\172\000\171\000\
\\170\000\169\000\021\000\213\000\
\\126\000\212\000\019\000\127\000\
\\131\000\046\000\241\000\240\000\
\\239\000\035\000\018\000\057\000\
\\037\000\107\000\233\000\108\000\
\\092\000\094\000\022\000\103\000\
\\047\000\082\000\022\000\022\000\
\\010\000\096\000\208\000\209\000\
\\210\000\040\000\041\000\042\000\
\\193\000\192\000\186\000\185\000\
\\175\000\168\000\167\000\118\000\
\\117\000\114\000\054\000\112\000\
\\214\000\224\000\048\000\229\000\
\\230\000\146\000\223\000\203\000\
\\242\000\022\000\244\000\022\000\
\\243\000\022\000\099\000\120\000\
\\089\000\090\000\026\000\004\001\
\\022\000\020\000\057\000\022\000\
\\115\000\022\000\113\000\225\000\
\\226\000\022\000\222\000\130\000\
\\245\000\030\000\005\001\022\000\
\\049\000\055\000\050\000\217\000\
\\057\000\016\000\119\000\116\000\
\\227\000\228\000\022\000\051\000\
\\215\000\221\000\218\000\056\000\
\\220\000\031\000\216\000\022\000\
\\206\000\052\000\219\000\000\000"
val gotoT =
"\
\\001\000\051\001\009\000\004\000\010\000\003\000\011\000\002\000\
\\119\000\001\000\000\000\
\\010\000\007\000\011\000\002\000\000\000\
\\010\000\008\000\011\000\002\000\000\000\
\\119\000\009\000\000\000\
\\000\000\
\\033\000\011\000\120\000\010\000\000\000\
\\012\000\018\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\121\000\033\000\122\000\032\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\016\000\060\000\036\000\061\000\014\000\062\000\013\000\000\000\
\\014\000\042\000\015\000\041\000\016\000\040\000\017\000\039\000\
\\018\000\038\000\019\000\037\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\121\000\045\000\122\000\032\000\000\000\
\\000\000\
\\033\000\046\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\014\000\048\000\015\000\041\000\016\000\040\000\017\000\039\000\
\\018\000\038\000\019\000\037\000\000\000\
\\000\000\
\\000\000\
\\012\000\050\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\000\000\
\\000\000\
\\123\000\054\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\023\000\062\000\024\000\061\000\025\000\060\000\028\000\059\000\
\\029\000\058\000\000\000\
\\123\000\068\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\123\000\069\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\123\000\070\000\124\000\053\000\127\000\052\000\130\000\051\000\000\000\
\\000\000\
\\023\000\072\000\024\000\061\000\131\000\071\000\000\000\
\\033\000\076\000\038\000\075\000\128\000\074\000\129\000\073\000\000\000\
\\033\000\079\000\125\000\078\000\126\000\077\000\000\000\
\\028\000\080\000\029\000\058\000\000\000\
\\000\000\
\\026\000\083\000\027\000\082\000\032\000\081\000\000\000\
\\023\000\087\000\024\000\061\000\000\000\
\\000\000\
\\033\000\088\000\000\000\
\\033\000\076\000\038\000\091\000\039\000\090\000\000\000\
\\033\000\093\000\000\000\
\\033\000\095\000\000\000\
\\020\000\101\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\076\000\038\000\075\000\128\000\074\000\129\000\107\000\000\000\
\\000\000\
\\108\000\108\000\000\000\
\\000\000\
\\033\000\079\000\125\000\078\000\126\000\110\000\000\000\
\\000\000\
\\000\000\
\\033\000\112\000\000\000\
\\026\000\114\000\027\000\082\000\032\000\081\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\133\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\040\000\149\000\000\000\
\\041\000\151\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\154\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\033\000\161\000\034\000\160\000\035\000\159\000\036\000\158\000\
\\037\000\157\000\038\000\156\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\021\000\164\000\022\000\163\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\020\000\167\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\000\000\
\\033\000\076\000\038\000\091\000\039\000\168\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\170\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\171\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\093\000\173\000\094\000\172\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\092\000\176\000\
\\095\000\117\000\096\000\116\000\000\000\
\\086\000\179\000\087\000\178\000\090\000\177\000\000\000\
\\082\000\184\000\083\000\183\000\088\000\182\000\000\000\
\\079\000\188\000\084\000\187\000\000\000\
\\076\000\197\000\080\000\196\000\116\000\195\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\050\000\205\000\051\000\204\000\100\000\203\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\209\000\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\033\000\076\000\038\000\214\000\074\000\213\000\103\000\212\000\
\\110\000\211\000\111\000\210\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\216\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\041\000\217\000\000\000\
\\000\000\
\\033\000\076\000\038\000\091\000\039\000\218\000\000\000\
\\000\000\
\\020\000\219\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\220\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\033\000\161\000\034\000\221\000\035\000\159\000\036\000\158\000\
\\037\000\157\000\038\000\156\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\025\000\223\000\108\000\108\000\000\000\
\\020\000\224\000\033\000\100\000\043\000\099\000\049\000\098\000\
\\053\000\097\000\000\000\
\\021\000\225\000\022\000\163\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\229\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\093\000\230\000\094\000\172\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\096\000\231\000\000\000\
\\033\000\234\000\061\000\233\000\097\000\232\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\089\000\236\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\086\000\237\000\087\000\178\000\090\000\177\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\085\000\238\000\
\\089\000\120\000\091\000\119\000\092\000\118\000\095\000\117\000\
\\096\000\116\000\000\000\
\\000\000\
\\082\000\184\000\083\000\239\000\088\000\182\000\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\081\000\240\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\077\000\241\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\076\000\197\000\080\000\196\000\116\000\242\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\044\000\246\000\045\000\245\000\047\000\244\000\048\000\243\000\
\\052\000\134\000\055\000\208\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\100\000\248\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\250\000\107\000\249\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\110\000\000\001\111\000\210\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\112\000\002\001\000\000\
\\033\000\076\000\038\000\214\000\103\000\004\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\006\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\008\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\009\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\026\000\011\001\027\000\082\000\032\000\081\000\041\000\010\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\046\000\016\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\105\000\020\001\106\000\019\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\108\000\108\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\023\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\024\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\025\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\026\000\026\001\027\000\082\000\032\000\081\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\091\000\
\\039\000\029\001\043\000\135\000\048\000\028\001\052\000\134\000\
\\055\000\208\000\056\000\132\000\060\000\015\000\061\000\014\000\
\\062\000\013\000\063\000\131\000\064\000\130\000\066\000\129\000\
\\067\000\128\000\068\000\127\000\069\000\126\000\070\000\125\000\
\\075\000\124\000\077\000\123\000\081\000\122\000\085\000\121\000\
\\089\000\120\000\091\000\119\000\092\000\118\000\095\000\117\000\
\\096\000\116\000\109\000\027\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\030\001\107\000\249\000\000\000\
\\033\000\076\000\038\000\091\000\039\000\033\001\102\000\032\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\034\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\044\000\035\001\045\000\245\000\047\000\244\000\048\000\243\000\
\\052\000\134\000\055\000\208\000\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\105\000\020\001\106\000\036\001\000\000\
\\012\000\136\000\013\000\017\000\033\000\253\000\038\000\252\000\
\\043\000\135\000\048\000\251\000\052\000\134\000\055\000\208\000\
\\056\000\132\000\060\000\015\000\061\000\014\000\062\000\013\000\
\\063\000\131\000\064\000\130\000\066\000\129\000\067\000\128\000\
\\068\000\127\000\069\000\126\000\070\000\125\000\075\000\124\000\
\\077\000\123\000\081\000\122\000\085\000\121\000\089\000\120\000\
\\091\000\119\000\092\000\118\000\095\000\117\000\096\000\116\000\
\\104\000\037\001\107\000\249\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\039\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\033\000\076\000\038\000\214\000\103\000\043\001\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\052\000\134\000\055\000\045\001\056\000\132\000\060\000\015\000\
\\061\000\014\000\062\000\013\000\063\000\131\000\064\000\130\000\
\\066\000\129\000\067\000\128\000\068\000\127\000\069\000\126\000\
\\070\000\125\000\075\000\124\000\077\000\123\000\081\000\122\000\
\\085\000\121\000\089\000\120\000\091\000\119\000\092\000\118\000\
\\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\\012\000\136\000\013\000\017\000\033\000\016\000\043\000\135\000\
\\048\000\049\001\052\000\134\000\055\000\208\000\056\000\132\000\
\\060\000\015\000\061\000\014\000\062\000\013\000\063\000\131\000\
\\064\000\130\000\066\000\129\000\067\000\128\000\068\000\127\000\
\\069\000\126\000\070\000\125\000\075\000\124\000\077\000\123\000\
\\081\000\122\000\085\000\121\000\089\000\120\000\091\000\119\000\
\\092\000\118\000\095\000\117\000\096\000\116\000\000\000\
\\000\000\
\\000\000\
\\000\000\
\\000\000\
\"
val numstates = 308
val numrules = 211
val s = ref "" and index = ref 0
val string_to_int = fn () => 
let val i = !index
in index := i+2; Char.ord(String.sub(!s,i)) + Char.ord(String.sub(!s,i+1)) * 256
end
val string_to_list = fn s' =>
    let val len = String.size s'
        fun f () =
           if !index < len then string_to_int() :: f()
           else nil
   in index := 0; s := s'; f ()
   end
val string_to_pairlist = fn (conv_key,conv_entry) =>
     let fun f () =
         case string_to_int()
         of 0 => EMPTY
          | n => PAIR(conv_key (n-1),conv_entry (string_to_int()),f())
     in f
     end
val string_to_pairlist_default = fn (conv_key,conv_entry) =>
    let val conv_row = string_to_pairlist(conv_key,conv_entry)
    in fn () =>
       let val default = conv_entry(string_to_int())
           val row = conv_row()
       in (row,default)
       end
   end
val string_to_table = fn (convert_row,s') =>
    let val len = String.size s'
        fun f ()=
           if !index < len then convert_row() :: f()
           else nil
     in (s := s'; index := 0; f ())
     end
local
  val memo = Array.array(numstates+numrules,ERROR)
  val _ =let fun g i=(Array.update(memo,i,REDUCE(i-numstates)); g(i+1))
       fun f i =
            if i=numstates then g i
            else (Array.update(memo,i,SHIFT (STATE i)); f (i+1))
          in f 0 handle Subscript => ()
          end
in
val entry_to_action = fn 0 => ACCEPT | 1 => ERROR | j => Array.sub(memo,(j-2))
end
val gotoT=Array.fromList(string_to_table(string_to_pairlist(NT,STATE),gotoT))
val actionRows=string_to_table(string_to_pairlist_default(T,entry_to_action),actionRows)
val actionRowNumbers = string_to_list actionRowNumbers
val actionT = let val actionRowLookUp=
let val a=Array.fromList(actionRows) in fn i=>Array.sub(a,i) end
in Array.fromList(map actionRowLookUp actionRowNumbers)
end
in LrTable.mkLrTable {actions=actionT,gotos=gotoT,numRules=numrules,
numStates=numstates,initialState=STATE 0}
end
end
local open Header in
type pos =  ( int * int * int ) 
type arg = unit
structure MlyValue = 
struct
datatype svalue = VOID | ntVOID of unit ->  unit
 | CLASS of unit ->  (string) | CONSTRAINTS of unit ->  (string)
 | END of unit ->  (string) | BETWEEN of unit ->  (string)
 | ASSOCIATIONS of unit ->  (string) | ATTRIBUTES of unit ->  (string)
 | OPERATIONS of unit ->  (string) | MODEL of unit ->  (string)
 | SIMPLE_NAME of unit ->  (string)
 | STRING_LITERAL of unit ->  (string)
 | REAL_LITERAL of unit ->  (string)
 | INTEGER_LITERAL of unit ->  (string) | NOT of unit ->  (string)
 | LOG_IMPL of unit ->  (string) | LOG_XOR of unit ->  (string)
 | LOG_OR of unit ->  (string) | LOG_AND of unit ->  (string)
 | REL_LTE of unit ->  (string) | REL_GTE of unit ->  (string)
 | REL_LT of unit ->  (string) | REL_GT of unit ->  (string)
 | REL_NOTEQUAL of unit ->  (string) | PLUS of unit ->  (string)
 | SLASH of unit ->  (string) | STAR of unit ->  (string)
 | MINUS of unit ->  (string) | OCLASTYPE of unit ->  (string)
 | OCLISKINDOF of unit ->  (string) | OCLISTYPEOF of unit ->  (string)
 | ISUNIQUE of unit ->  (string) | ONE of unit ->  (string)
 | EXISTS of unit ->  (string) | ANY of unit ->  (string)
 | COLLECT of unit ->  (string) | REJECT of unit ->  (string)
 | SELECT of unit ->  (string) | ITERATE of unit ->  (string)
 | GUARD of unit ->  (string) | VERTICAL_BAR of unit ->  (string)
 | BRACE_CLOSE of unit ->  (string) | BRACE_OPEN of unit ->  (string)
 | PAREN_CLOSE of unit ->  (string) | PAREN_OPEN of unit ->  (string)
 | THEN of unit ->  (string)
 | POST of unit ->  (Context.ConditionType)
 | PRE of unit ->  (Context.ConditionType)
 | PACKAGE of unit ->  (string) | LET of unit ->  (string)
 | INV of unit ->  (string) | INIT of unit ->  (Context.AttrOrAssoc)
 | IN of unit ->  (string) | IF of unit ->  (string)
 | TRUE of unit ->  (string) | FORALL of unit ->  (string)
 | NULL of unit ->  (string) | FALSE of unit ->  (string)
 | ENDPACKAGE of unit ->  (string) | ENDIF of unit ->  (string)
 | ELSE of unit ->  (string)
 | DERIVE of unit ->  (Context.AttrOrAssoc) | DEF of unit ->  (string)
 | CONTEXT of unit ->  (string)
 | BODY of unit ->  (Context.ConditionType)
 | DBL_CARAT of unit ->  (string) | CARAT of unit ->  (string)
 | BRACKET_CLOSE of unit ->  (string)
 | BRACKET_OPEN of unit ->  (string) | TUPLE_TYPE of unit ->  (string)
 | TUPLE of unit ->  (string) | SET of unit ->  (string)
 | ORDERED_SET of unit ->  (string) | SEQUENCE of unit ->  (string)
 | COLLECTION of unit ->  (string) | BAG of unit ->  (string)
 | AT_PRE of unit ->  (string) | HASH of unit ->  (string)
 | QUESTION_MARK of unit ->  (string) | EQUALS of unit ->  (string)
 | SEMI_COLON of unit ->  (string) | DBL_COLON of unit ->  (string)
 | COLON of unit ->  (string) | DBL_DOT of unit ->  (string)
 | DOT of unit ->  (string) | ARROW_RIGHT of unit ->  (string)
 | COMMA of unit ->  (string) | TICK of unit ->  (string)
 | model_cons_def_tail_cs_p of unit ->  ( ( string option * OclTerm )  list)
 | model_cons_spec_cs of unit ->  (Classifier)
 | model_att_value_def_tail_cs_p of unit ->  (attribute list)
 | model_att_value_def_cs of unit ->  (attribute)
 | model_atts_spec_cs of unit ->  (Classifier)
 | model_op_def_tail_cs_p of unit ->  (operation list)
 | model_op_def_cs of unit ->  (operation)
 | model_ops_spec_cs of unit ->  (Classifier)
 | model_component_def_cs of unit ->  ( ( Classifier list ) )
 | model_class_def_cs of unit ->  ( ( Path * Classifier ) )
 | model_class_def_tail_cs_p of unit ->  ( ( Path * Classifier )  list)
 | model_def_cs of unit ->  (Classifier list)
 | model_spec_cs of unit ->  (Classifier list)
 | logical_exp_tail_cs_p of unit ->  ( ( string * OclTerm ) )
 | variable_declaration_list_tail_cs of unit ->  ( ( string*OclType )  list)
 | variable_declaration_list_cs of unit ->  ( ( string*OclType )  list)
 | variable_declaration_cs of unit ->  ( ( string*OclType ) )
 | variable_initializer of unit ->  (OclTerm)
 | initialized_variable_list_tail_cs of unit ->  ( ( string * OclType * OclTerm ) )
 | initialized_variable_list_tail_cs_p of unit ->  ( ( string * OclType * OclTerm )  list)
 | iterator_vars_cs of unit ->  ( ( string*OclType )  list)
 | formal_parameter_type_specifier of unit ->  (OclType)
 | actual_parameter_list_element_cs of unit ->  ( ( OclTerm * OclType ) )
 | actual_parameter_list_tail_cs_p of unit ->  ( ( OclTerm * OclType )  list)
 | actual_parameter_list_tail_cs of unit ->  ( ( OclTerm * OclType )  list)
 | actual_parameter_list_cs of unit ->  ( ( OclTerm * OclType )  list)
 | initialized_variable_cs of unit ->  ( ( string * OclType * OclTerm ) )
 | iterate_vars_cs of unit ->  ( ( string * OclType )  list)
 | qualifiers of unit ->  (CollectionPart list)
 | property_call_parameters_cs of unit ->  ( ( OclTerm * OclType )  list)
 | msg_operator_cs of unit ->  (OclTerm)
 | signal_spec_exp_cs of unit ->  (OclTerm)
 | arrow_property_call_exp_cs of unit ->  (OclTerm)
 | property_call_exp_cs of unit ->  (OclTerm)
 | primary_exp_cs of unit ->  (OclTerm)
 | postfix_exp_tail_cs of unit ->  (OclTerm)
 | postfix_exp_tail_cs_p of unit ->  (OclTerm list)
 | postfix_exp_cs of unit ->  (OclTerm)
 | unary_op of unit ->  (string) | mult_op of unit ->  (string)
 | unary_exp_cs of unit ->  (OclTerm) | add_op of unit ->  (string)
 | multiplicative_exp_tail_cs of unit ->  ( ( string*OclTerm ) )
 | multiplicative_exp_tail_cs_p of unit ->  ( ( string*OclTerm ) )
 | multiplicative_exp_cs of unit ->  (OclTerm)
 | rel_op of unit ->  (string)
 | additive_exp_tail_cs_p of unit ->  ( ( string*OclTerm ) )
 | additive_exp_tail_cs of unit ->  ( ( string*OclTerm ) )
 | additive_exp_cs of unit ->  (OclTerm)
 | logic_op of unit ->  (string)
 | relational_exp_tail_cs of unit ->  ( ( string*OclTerm ) )
 | relational_exp_tail_cs_p of unit ->  ( ( string*OclTerm ) )
 | relational_exp_cs of unit ->  (OclTerm)
 | logical_exp_tail_cs of unit ->  ( ( string*OclTerm ) )
 | logical_exp_cs of unit ->  (OclTerm)
 | initialized_variable_list_cs of unit ->  ( ( string * OclType * OclTerm )  list)
 | string_literal of unit ->  (OclTerm)
 | real_literal of unit ->  (OclTerm)
 | integer_literal of unit ->  (OclTerm)
 | invalid_literal_exp_cs of unit ->  (OclTerm)
 | boolean_literal_exp_cs of unit ->  (OclTerm)
 | string_literal_exp_cs of unit ->  (OclTerm)
 | numeric_literal_exp_cs of unit ->  (OclTerm)
 | primitive_literal_exp_cs of unit ->  (OclTerm)
 | tuple_literal_exp_cs of unit ->  (OclTerm)
 | collection_literal_exp_cs of unit ->  (OclTerm)
 | literal_exp_cs of unit ->  (OclTerm)
 | ocl_op_name of unit ->  (string)
 | iterator_name_cs of unit ->  (string)
 | identifier_cs of unit ->  (string)
 | let_exp_cs of unit ->  (OclTerm)
 | ocl_expression_cs of unit ->  (OclTerm)
 | tuple_type_specifier_cs of unit ->  (OclType)
 | simple_type_specifier_cs of unit ->  (OclType)
 | if_exp_cs of unit ->  (OclTerm)
 | is_marked_pre_cs of unit ->  (string)
 | time_exp_cs of unit ->  (string)
 | collection_type_specifier_cs of unit ->  (OclType)
 | expression of unit ->  (OclTerm)
 | collection_range_cs of unit ->  (CollectionPart)
 | collection_literal_parts_tail_cs of unit ->  (CollectionPart list)
 | collection_literal_part_cs of unit ->  (CollectionPart)
 | collection_literal_parts_cs of unit ->  (CollectionPart list)
 | collection_type_identifier_cs of unit ->  (string)
 | collection_literal_exp of unit ->  (OclTerm)
 | operation_return_type_specifier_cs of unit ->  (OclType)
 | formal_parameter_list_tail_cs of unit ->  ( ( string * OclType )  list)
 | formal_parameter_list_cs of unit ->  ( ( string * OclType )  list)
 | formal_parameter_cs of unit ->  ( ( string * OclType ) )
 | ocl_operation_defined_entity_decl_cs of unit ->  (string* ( (string * OclType) list ) )
 | ocl_attribute_defined_entity_decl_cs of unit ->  ( ( string * OclType ) )
 | defined_entity_decl_cs of unit ->  (OclTerm)
 | definition_constraint_cs of unit ->  (OclTerm)
 | simple_name of unit ->  (string)
 | op_constraint_stereotype_cs of unit ->  (Context.ConditionType)
 | definition_cs of unit ->  (OclTerm)
 | invariant_cs of unit ->  (OclTerm)
 | guard_constraint_cs of unit ->  ( ( string option*OclTerm ) )
 | guard_constraint_cs_p of unit ->  ( ( string option*OclTerm )  list)
 | operation_constraint_cs of unit ->  ( ( Context.ConditionType*string option*OclTerm ) )
 | operation_constraint_cs_p of unit ->  ( ( Context.ConditionType*string option*OclTerm )  list)
 | operation_signature_cs of unit ->  ( ( string * OclType )  list)
 | classifier_constraint_cs of unit ->  ( ( string option*OclTerm ) )
 | classifier_constraint_cs_p of unit ->  ( ( string option*OclTerm )  list)
 | init_or_der_value_cs of unit ->  ( ( AttrOrAssoc*OclTerm ) )
 | init_or_der_value_cs_p of unit ->  ( ( AttrOrAssoc*OclTerm )  list)
 | type_specifier of unit ->  (OclType)
 | guard_context_declaration_cs of unit ->  (context list)
 | operation_context_declaration_cs of unit ->  (context list)
 | classifier_context_declaration_cs of unit ->  (context list)
 | attr_or_assoc_cs of unit ->  (context list)
 | context_declaration_cs of unit ->  (context list)
 | context_declaration_list_cs of unit ->  (context list)
 | path_name_head_cs of unit ->  (Path)
 | path_name_cs of unit ->  (Path)
 | package_constraint_list_cs of unit ->  (context list)
 | package_constraint_list_cs_p of unit ->  (context list)
 | ocl_file of unit ->  ( ( context list * Classifier list ) )
 | RealLiteralExp of unit ->  (Rep_OclTerm.OclTerm)
 | StringLiteralExp of unit ->  (Rep_OclTerm.OclTerm)
 | BooleanLiteralExp of unit ->  (Rep_OclTerm.OclTerm)
 | IntegerLiteralExp of unit ->  (Rep_OclTerm.OclTerm)
 | PrimitiveLiteralExp of unit ->  (Rep_OclTerm.OclTerm)
 | LiteralExp of unit ->  (OclTerm)
 | OclExpression of unit ->  (Rep_OclTerm.OclTerm)
 | START of unit ->  ( ( context list * Classifier list ) )
end
type svalue = MlyValue.svalue
type result =  ( context list * Classifier list ) 
end
structure EC=
struct
open LrTable
infix 5 $$
fun x $$ y = y::x
val is_keyword =
fn _ => false
val preferred_change : (term list * term list) list = 
nil
val noShift = 
fn (T 0) => true | _ => false
val showTerminal =
fn (T 0) => "EOF"
  | (T 1) => "TICK"
  | (T 2) => "COMMA"
  | (T 3) => "ARROW_RIGHT"
  | (T 4) => "DOT"
  | (T 5) => "DBL_DOT"
  | (T 6) => "COLON"
  | (T 7) => "DBL_COLON"
  | (T 8) => "SEMI_COLON"
  | (T 9) => "EQUALS"
  | (T 10) => "QUESTION_MARK"
  | (T 11) => "HASH"
  | (T 12) => "AT_PRE"
  | (T 13) => "BAG"
  | (T 14) => "COLLECTION"
  | (T 15) => "SEQUENCE"
  | (T 16) => "ORDERED_SET"
  | (T 17) => "SET"
  | (T 18) => "TUPLE"
  | (T 19) => "TUPLE_TYPE"
  | (T 20) => "BRACKET_OPEN"
  | (T 21) => "BRACKET_CLOSE"
  | (T 22) => "CARAT"
  | (T 23) => "DBL_CARAT"
  | (T 24) => "BODY"
  | (T 25) => "CONTEXT"
  | (T 26) => "DEF"
  | (T 27) => "DERIVE"
  | (T 28) => "ELSE"
  | (T 29) => "ENDIF"
  | (T 30) => "ENDPACKAGE"
  | (T 31) => "FALSE"
  | (T 32) => "NULL"
  | (T 33) => "FORALL"
  | (T 34) => "TRUE"
  | (T 35) => "IF"
  | (T 36) => "IN"
  | (T 37) => "INIT"
  | (T 38) => "INV"
  | (T 39) => "LET"
  | (T 40) => "PACKAGE"
  | (T 41) => "PRE"
  | (T 42) => "POST"
  | (T 43) => "THEN"
  | (T 44) => "PAREN_OPEN"
  | (T 45) => "PAREN_CLOSE"
  | (T 46) => "BRACE_OPEN"
  | (T 47) => "BRACE_CLOSE"
  | (T 48) => "VERTICAL_BAR"
  | (T 49) => "GUARD"
  | (T 50) => "ITERATE"
  | (T 51) => "SELECT"
  | (T 52) => "REJECT"
  | (T 53) => "COLLECT"
  | (T 54) => "ANY"
  | (T 55) => "EXISTS"
  | (T 56) => "ONE"
  | (T 57) => "ISUNIQUE"
  | (T 58) => "OCLISTYPEOF"
  | (T 59) => "OCLISKINDOF"
  | (T 60) => "OCLASTYPE"
  | (T 61) => "MINUS"
  | (T 62) => "STAR"
  | (T 63) => "SLASH"
  | (T 64) => "PLUS"
  | (T 65) => "REL_NOTEQUAL"
  | (T 66) => "REL_GT"
  | (T 67) => "REL_LT"
  | (T 68) => "REL_GTE"
  | (T 69) => "REL_LTE"
  | (T 70) => "LOG_AND"
  | (T 71) => "LOG_OR"
  | (T 72) => "LOG_XOR"
  | (T 73) => "LOG_IMPL"
  | (T 74) => "NOT"
  | (T 75) => "INTEGER_LITERAL"
  | (T 76) => "REAL_LITERAL"
  | (T 77) => "STRING_LITERAL"
  | (T 78) => "SIMPLE_NAME"
  | (T 79) => "MODEL"
  | (T 80) => "OPERATIONS"
  | (T 81) => "ATTRIBUTES"
  | (T 82) => "ASSOCIATIONS"
  | (T 83) => "BETWEEN"
  | (T 84) => "END"
  | (T 85) => "CONSTRAINTS"
  | (T 86) => "CLASS"
  | _ => "bogus-term"
local open Header in
val errtermvalue=
fn _ => MlyValue.VOID
end
val terms : term list = nil
 $$ (T 0)end
structure Actions =
struct 
type int = Int.int
exception mlyAction of int
local open Header in
val actions = 
fn (i392:int,defaultPos,stack,
    (()):arg) =>
case (i392,stack)
of  ( 0, ( ( _, ( MlyValue.ocl_file ocl_file1, ocl_file1left, 
ocl_file1right)) :: rest671)) => let val  result = MlyValue.START (fn
 _ => let val  (ocl_file as ocl_file1) = ocl_file1 ()
 in (ocl_file)
end)
 in ( LrTable.NT 0, ( result, ocl_file1left, ocl_file1right), rest671)

end
|  ( 1, ( ( _, ( MlyValue.package_constraint_list_cs_p 
package_constraint_list_cs_p1, package_constraint_list_cs_p1left, 
package_constraint_list_cs_p1right)) :: rest671)) => let val  result =
 MlyValue.ocl_file (fn _ => let val  (package_constraint_list_cs_p as 
package_constraint_list_cs_p1) = package_constraint_list_cs_p1 ()
 in (package_constraint_list_cs_p,[])
end)
 in ( LrTable.NT 8, ( result, package_constraint_list_cs_p1left, 
package_constraint_list_cs_p1right), rest671)
end
|  ( 2, ( ( _, ( MlyValue.model_spec_cs model_spec_cs1, 
model_spec_cs1left, model_spec_cs1right)) :: rest671)) => let val  
result = MlyValue.ocl_file (fn _ => let val  (model_spec_cs as 
model_spec_cs1) = model_spec_cs1 ()
 in ([],model_spec_cs)
end)
 in ( LrTable.NT 8, ( result, model_spec_cs1left, model_spec_cs1right)
, rest671)
end
|  ( 3, ( ( _, ( MlyValue.model_spec_cs model_spec_cs1, _, 
model_spec_cs1right)) :: ( _, ( MlyValue.package_constraint_list_cs_p 
package_constraint_list_cs_p1, package_constraint_list_cs_p1left, _))
 :: rest671)) => let val  result = MlyValue.ocl_file (fn _ => let val 
 (package_constraint_list_cs_p as package_constraint_list_cs_p1) = 
package_constraint_list_cs_p1 ()
 val  (model_spec_cs as model_spec_cs1) = model_spec_cs1 ()
 in (package_constraint_list_cs_p,model_spec_cs)
end)
 in ( LrTable.NT 8, ( result, package_constraint_list_cs_p1left, 
model_spec_cs1right), rest671)
end
|  ( 4, ( ( _, ( MlyValue.package_constraint_list_cs_p 
package_constraint_list_cs_p1, _, package_constraint_list_cs_p1right))
 :: ( _, ( MlyValue.model_spec_cs model_spec_cs1, model_spec_cs1left,
 _)) :: rest671)) => let val  result = MlyValue.ocl_file (fn _ => let
 val  (model_spec_cs as model_spec_cs1) = model_spec_cs1 ()
 val  (package_constraint_list_cs_p as package_constraint_list_cs_p1)
 = package_constraint_list_cs_p1 ()
 in (package_constraint_list_cs_p,model_spec_cs)
end)
 in ( LrTable.NT 8, ( result, model_spec_cs1left, 
package_constraint_list_cs_p1right), rest671)
end
|  ( 5, ( ( _, ( MlyValue.package_constraint_list_cs 
package_constraint_list_cs1, package_constraint_list_cs1left, 
package_constraint_list_cs1right)) :: rest671)) => let val  result = 
MlyValue.package_constraint_list_cs_p (fn _ => let val  (
package_constraint_list_cs as package_constraint_list_cs1) = 
package_constraint_list_cs1 ()
 in (package_constraint_list_cs)
end)
 in ( LrTable.NT 9, ( result, package_constraint_list_cs1left, 
package_constraint_list_cs1right), rest671)
end
|  ( 6, ( ( _, ( MlyValue.package_constraint_list_cs_p 
package_constraint_list_cs_p1, _, package_constraint_list_cs_p1right))
 :: ( _, ( MlyValue.package_constraint_list_cs 
package_constraint_list_cs1, package_constraint_list_cs1left, _)) :: 
rest671)) => let val  result = MlyValue.package_constraint_list_cs_p
 (fn _ => let val  (package_constraint_list_cs as 
package_constraint_list_cs1) = package_constraint_list_cs1 ()
 val  (package_constraint_list_cs_p as package_constraint_list_cs_p1)
 = package_constraint_list_cs_p1 ()
 in (package_constraint_list_cs@package_constraint_list_cs_p)
end)
 in ( LrTable.NT 9, ( result, package_constraint_list_cs1left, 
package_constraint_list_cs_p1right), rest671)
end
|  ( 7, ( ( _, ( MlyValue.ENDPACKAGE ENDPACKAGE1, _, ENDPACKAGE1right)
) :: ( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, ( 
MlyValue.PACKAGE PACKAGE1, PACKAGE1left, _)) :: rest671)) => let val  
result = MlyValue.package_constraint_list_cs (fn _ => let val  
PACKAGE1 = PACKAGE1 ()
 val  path_name_cs1 = path_name_cs1 ()
 val  ENDPACKAGE1 = ENDPACKAGE1 ()
 in (
Logger.debug3 ("Starts creatind empty package ... " ^ "\n"); ([Empty_context ("this is an empty context", Literal ("empty",OclVoid))])
)
end)
 in ( LrTable.NT 10, ( result, PACKAGE1left, ENDPACKAGE1right), 
rest671)
end
|  ( 8, ( ( _, ( MlyValue.ENDPACKAGE ENDPACKAGE1, _, ENDPACKAGE1right)
) :: ( _, ( MlyValue.context_declaration_list_cs 
context_declaration_list_cs1, _, _)) :: ( _, ( MlyValue.path_name_cs 
path_name_cs1, _, _)) :: ( _, ( MlyValue.PACKAGE PACKAGE1, 
PACKAGE1left, _)) :: rest671)) => let val  result = 
MlyValue.package_constraint_list_cs (fn _ => let val  PACKAGE1 = 
PACKAGE1 ()
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  (context_declaration_list_cs as context_declaration_list_cs1) = 
context_declaration_list_cs1 ()
 val  ENDPACKAGE1 = ENDPACKAGE1 ()
 in (
Logger.debug3 ("Starts creating contextes ..." ^ "\n"); (list_extend_path path_name_cs context_declaration_list_cs)
)
end)
 in ( LrTable.NT 10, ( result, PACKAGE1left, ENDPACKAGE1right), 
rest671)
end
|  ( 9, ( ( _, ( MlyValue.context_declaration_cs 
context_declaration_cs1, context_declaration_cs1left, 
context_declaration_cs1right)) :: rest671)) => let val  result = 
MlyValue.context_declaration_list_cs (fn _ => let val  (
context_declaration_cs as context_declaration_cs1) = 
context_declaration_cs1 ()
 in (context_declaration_cs)
end)
 in ( LrTable.NT 13, ( result, context_declaration_cs1left, 
context_declaration_cs1right), rest671)
end
|  ( 10, ( ( _, ( MlyValue.context_declaration_list_cs 
context_declaration_list_cs1, _, context_declaration_list_cs1right))
 :: ( _, ( MlyValue.context_declaration_cs context_declaration_cs1, 
context_declaration_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.context_declaration_list_cs (fn _ => let val  (
context_declaration_cs as context_declaration_cs1) = 
context_declaration_cs1 ()
 val  (context_declaration_list_cs as context_declaration_list_cs1) = 
context_declaration_list_cs1 ()
 in (context_declaration_cs@context_declaration_list_cs)
end)
 in ( LrTable.NT 13, ( result, context_declaration_cs1left, 
context_declaration_list_cs1right), rest671)
end
|  ( 11, ( ( _, ( MlyValue.attr_or_assoc_cs attr_or_assoc_cs1, 
attr_or_assoc_cs1left, attr_or_assoc_cs1right)) :: rest671)) => let
 val  result = MlyValue.context_declaration_cs (fn _ => let val  (
attr_or_assoc_cs as attr_or_assoc_cs1) = attr_or_assoc_cs1 ()
 in (attr_or_assoc_cs)
end)
 in ( LrTable.NT 14, ( result, attr_or_assoc_cs1left, 
attr_or_assoc_cs1right), rest671)
end
|  ( 12, ( ( _, ( MlyValue.classifier_context_declaration_cs 
classifier_context_declaration_cs1, 
classifier_context_declaration_cs1left, 
classifier_context_declaration_cs1right)) :: rest671)) => let val  
result = MlyValue.context_declaration_cs (fn _ => let val  (
classifier_context_declaration_cs as 
classifier_context_declaration_cs1) = 
classifier_context_declaration_cs1 ()
 in (classifier_context_declaration_cs)
end)
 in ( LrTable.NT 14, ( result, classifier_context_declaration_cs1left,
 classifier_context_declaration_cs1right), rest671)
end
|  ( 13, ( ( _, ( MlyValue.operation_context_declaration_cs 
operation_context_declaration_cs1, 
operation_context_declaration_cs1left, 
operation_context_declaration_cs1right)) :: rest671)) => let val  
result = MlyValue.context_declaration_cs (fn _ => let val  (
operation_context_declaration_cs as operation_context_declaration_cs1)
 = operation_context_declaration_cs1 ()
 in (operation_context_declaration_cs)
end)
 in ( LrTable.NT 14, ( result, operation_context_declaration_cs1left, 
operation_context_declaration_cs1right), rest671)
end
|  ( 14, ( ( _, ( MlyValue.guard_context_declaration_cs 
guard_context_declaration_cs1, guard_context_declaration_cs1left, 
guard_context_declaration_cs1right)) :: rest671)) => let val  result =
 MlyValue.context_declaration_cs (fn _ => let val  (
guard_context_declaration_cs as guard_context_declaration_cs1) = 
guard_context_declaration_cs1 ()
 in (guard_context_declaration_cs)
end)
 in ( LrTable.NT 14, ( result, guard_context_declaration_cs1left, 
guard_context_declaration_cs1right), rest671)
end
|  ( 15, ( ( _, ( MlyValue.init_or_der_value_cs_p 
init_or_der_value_cs_p1, _, init_or_der_value_cs_p1right)) :: ( _, ( 
MlyValue.type_specifier type_specifier1, _, _)) :: ( _, ( 
MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.path_name_cs 
path_name_cs1, _, _)) :: ( _, ( MlyValue.CONTEXT CONTEXT1, 
CONTEXT1left, _)) :: rest671)) => let val  result = 
MlyValue.attr_or_assoc_cs (fn _ => let val  CONTEXT1 = CONTEXT1 ()
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  COLON1 = COLON1 ()
 val  (type_specifier as type_specifier1) = type_specifier1 ()
 val  (init_or_der_value_cs_p as init_or_der_value_cs_p1) = 
init_or_der_value_cs_p1 ()
 in (attr_list (path_name_cs, type_specifier, init_or_der_value_cs_p))

end)
 in ( LrTable.NT 15, ( result, CONTEXT1left, 
init_or_der_value_cs_p1right), rest671)
end
|  ( 16, ( ( _, ( MlyValue.SIMPLE_NAME SIMPLE_NAME1, SIMPLE_NAME1left,
 SIMPLE_NAME1right)) :: rest671)) => let val  result = 
MlyValue.simple_name (fn _ => let val  (SIMPLE_NAME as SIMPLE_NAME1) =
 SIMPLE_NAME1 ()
 in (Logger.debug3 ("simple_name..." ^ "\n");SIMPLE_NAME)
end)
 in ( LrTable.NT 32, ( result, SIMPLE_NAME1left, SIMPLE_NAME1right), 
rest671)
end
|  ( 17, ( ( _, ( MlyValue.classifier_constraint_cs_p 
classifier_constraint_cs_p1, _, classifier_constraint_cs_p1right)) :: 
( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, ( 
MlyValue.CONTEXT CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val  
result = MlyValue.classifier_context_declaration_cs (fn _ => let val  
CONTEXT1 = CONTEXT1 ()
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  (classifier_constraint_cs_p as classifier_constraint_cs_p1) = 
classifier_constraint_cs_p1 ()
 in (inv_list (path_name_cs, classifier_constraint_cs_p))
end)
 in ( LrTable.NT 16, ( result, CONTEXT1left, 
classifier_constraint_cs_p1right), rest671)
end
|  ( 18, ( ( _, ( MlyValue.operation_constraint_cs_p 
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
 _, ( MlyValue.operation_signature_cs operation_signature_cs1, _, _))
 :: ( _, ( MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, ( 
MlyValue.CONTEXT CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val  
result = MlyValue.operation_context_declaration_cs (fn _ => let val  
CONTEXT1 = CONTEXT1 ()
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  (operation_signature_cs as operation_signature_cs1) = 
operation_signature_cs1 ()
 val  (operation_constraint_cs_p as operation_constraint_cs_p1) = 
operation_constraint_cs_p1 ()
 in (
cond_list (path_name_cs, operation_signature_cs, operation_constraint_cs_p)
)
end)
 in ( LrTable.NT 17, ( result, CONTEXT1left, 
operation_constraint_cs_p1right), rest671)
end
|  ( 19, ( ( _, ( MlyValue.guard_constraint_cs_p 
guard_constraint_cs_p1, _, guard_constraint_cs_p1right)) :: ( _, ( 
MlyValue.path_name_cs path_name_cs1, _, _)) :: ( _, ( MlyValue.CONTEXT
 CONTEXT1, CONTEXT1left, _)) :: rest671)) => let val  result = 
MlyValue.guard_context_declaration_cs (fn _ => let val  CONTEXT1 = 
CONTEXT1 ()
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  (guard_constraint_cs_p as guard_constraint_cs_p1) = 
guard_constraint_cs_p1 ()
 in (guard_list (real_path (path_name_cs), guard_constraint_cs_p))
end
)
 in ( LrTable.NT 18, ( result, CONTEXT1left, 
guard_constraint_cs_p1right), rest671)
end
|  ( 20, ( ( _, ( MlyValue.init_or_der_value_cs init_or_der_value_cs1,
 init_or_der_value_cs1left, init_or_der_value_cs1right)) :: rest671))
 => let val  result = MlyValue.init_or_der_value_cs_p (fn _ => let
 val  (init_or_der_value_cs as init_or_der_value_cs1) = 
init_or_der_value_cs1 ()
 in ([init_or_der_value_cs])
end)
 in ( LrTable.NT 20, ( result, init_or_der_value_cs1left, 
init_or_der_value_cs1right), rest671)
end
|  ( 21, ( ( _, ( MlyValue.init_or_der_value_cs_p 
init_or_der_value_cs_p1, _, init_or_der_value_cs_p1right)) :: ( _, ( 
MlyValue.init_or_der_value_cs init_or_der_value_cs1, 
init_or_der_value_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.init_or_der_value_cs_p (fn _ => let val  (
init_or_der_value_cs as init_or_der_value_cs1) = init_or_der_value_cs1
 ()
 val  (init_or_der_value_cs_p as init_or_der_value_cs_p1) = 
init_or_der_value_cs_p1 ()
 in ([init_or_der_value_cs]@init_or_der_value_cs_p)
end)
 in ( LrTable.NT 20, ( result, init_or_der_value_cs1left, 
init_or_der_value_cs_p1right), rest671)
end
|  ( 22, ( ( _, ( MlyValue.classifier_constraint_cs 
classifier_constraint_cs1, classifier_constraint_cs1left, 
classifier_constraint_cs1right)) :: rest671)) => let val  result = 
MlyValue.classifier_constraint_cs_p (fn _ => let val  (
classifier_constraint_cs as classifier_constraint_cs1) = 
classifier_constraint_cs1 ()
 in ([classifier_constraint_cs])
end)
 in ( LrTable.NT 22, ( result, classifier_constraint_cs1left, 
classifier_constraint_cs1right), rest671)
end
|  ( 23, ( ( _, ( MlyValue.classifier_constraint_cs_p 
classifier_constraint_cs_p1, _, classifier_constraint_cs_p1right)) :: 
( _, ( MlyValue.classifier_constraint_cs classifier_constraint_cs1, 
classifier_constraint_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.classifier_constraint_cs_p (fn _ => let val  (
classifier_constraint_cs as classifier_constraint_cs1) = 
classifier_constraint_cs1 ()
 val  (classifier_constraint_cs_p as classifier_constraint_cs_p1) = 
classifier_constraint_cs_p1 ()
 in ([classifier_constraint_cs]@classifier_constraint_cs_p)
end)
 in ( LrTable.NT 22, ( result, classifier_constraint_cs1left, 
classifier_constraint_cs_p1right), rest671)
end
|  ( 24, ( ( _, ( MlyValue.operation_constraint_cs 
operation_constraint_cs1, operation_constraint_cs1left, 
operation_constraint_cs1right)) :: rest671)) => let val  result = 
MlyValue.operation_constraint_cs_p (fn _ => let val  (
operation_constraint_cs as operation_constraint_cs1) = 
operation_constraint_cs1 ()
 in ([operation_constraint_cs])
end)
 in ( LrTable.NT 25, ( result, operation_constraint_cs1left, 
operation_constraint_cs1right), rest671)
end
|  ( 25, ( ( _, ( MlyValue.operation_constraint_cs_p 
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
 _, ( MlyValue.operation_constraint_cs operation_constraint_cs1, 
operation_constraint_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.operation_constraint_cs_p (fn _ => let val  (
operation_constraint_cs as operation_constraint_cs1) = 
operation_constraint_cs1 ()
 val  (operation_constraint_cs_p as operation_constraint_cs_p1) = 
operation_constraint_cs_p1 ()
 in ([operation_constraint_cs]@operation_constraint_cs_p)
end)
 in ( LrTable.NT 25, ( result, operation_constraint_cs1left, 
operation_constraint_cs_p1right), rest671)
end
|  ( 26, ( ( _, ( MlyValue.guard_constraint_cs guard_constraint_cs1, 
guard_constraint_cs1left, guard_constraint_cs1right)) :: rest671)) =>
 let val  result = MlyValue.guard_constraint_cs_p (fn _ => let val  (
guard_constraint_cs as guard_constraint_cs1) = guard_constraint_cs1 ()
 in ([guard_constraint_cs])
end)
 in ( LrTable.NT 27, ( result, guard_constraint_cs1left, 
guard_constraint_cs1right), rest671)
end
|  ( 27, ( ( _, ( MlyValue.guard_constraint_cs_p 
guard_constraint_cs_p1, _, guard_constraint_cs_p1right)) :: ( _, ( 
MlyValue.guard_constraint_cs guard_constraint_cs1, 
guard_constraint_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.guard_constraint_cs_p (fn _ => let val  (guard_constraint_cs
 as guard_constraint_cs1) = guard_constraint_cs1 ()
 val  (guard_constraint_cs_p as guard_constraint_cs_p1) = 
guard_constraint_cs_p1 ()
 in ([guard_constraint_cs]@guard_constraint_cs_p)
end)
 in ( LrTable.NT 27, ( result, guard_constraint_cs1left, 
guard_constraint_cs_p1right), rest671)
end
|  ( 28, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.INIT INIT1, INIT1left, _)) :: rest671)) => let val  
result = MlyValue.init_or_der_value_cs (fn _ => let val  (INIT as 
INIT1) = INIT1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (INIT, ocl_expression_cs)
end)
 in ( LrTable.NT 21, ( result, INIT1left, ocl_expression_cs1right), 
rest671)
end
|  ( 29, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.DERIVE DERIVE1, DERIVE1left, _)) :: rest671)) => let
 val  result = MlyValue.init_or_der_value_cs (fn _ => let val  (DERIVE
 as DERIVE1) = DERIVE1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (DERIVE, ocl_expression_cs)
end)
 in ( LrTable.NT 21, ( result, DERIVE1left, ocl_expression_cs1right), 
rest671)
end
|  ( 30, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.INV INV1, INV1left, _)) :: rest671)) => let val  result
 = MlyValue.classifier_constraint_cs (fn _ => let val  (INV as INV1) =
 INV1 ()
 val  (COLON as COLON1) = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (
Logger.debug3 ("INV COLON ocl_expression_cs ..." ^ "\n"); (NONE,ocl_expression_cs)
)
end)
 in ( LrTable.NT 23, ( result, INV1left, ocl_expression_cs1right), 
rest671)
end
|  ( 31, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, ( MlyValue.INV
 INV1, INV1left, _)) :: rest671)) => let val  result = 
MlyValue.classifier_constraint_cs (fn _ => let val  (INV as INV1) = 
INV1 ()
 val  (simple_name as simple_name1) = simple_name1 ()
 val  (COLON as COLON1) = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (
Logger.debug3 ("INV simple_name COLON ocl_expression_cs ..." ^ "\n");(SOME(simple_name),ocl_expression_cs)
)
end)
 in ( LrTable.NT 23, ( result, INV1left, ocl_expression_cs1right), 
rest671)
end
|  ( 32, ( ( _, ( MlyValue.definition_constraint_cs 
definition_constraint_cs1, _, definition_constraint_cs1right)) :: ( _,
 ( MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.DEF DEF1, DEF1left
, _)) :: rest671)) => let val  result = 
MlyValue.classifier_constraint_cs (fn _ => let val  DEF1 = DEF1 ()
 val  COLON1 = COLON1 ()
 val  (definition_constraint_cs as definition_constraint_cs1) = 
definition_constraint_cs1 ()
 in (NONE,definition_constraint_cs)
end)
 in ( LrTable.NT 23, ( result, DEF1left, 
definition_constraint_cs1right), rest671)
end
|  ( 33, ( ( _, ( MlyValue.definition_constraint_cs 
definition_constraint_cs1, _, definition_constraint_cs1right)) :: ( _,
 ( MlyValue.COLON COLON1, _, _)) :: ( _, ( MlyValue.simple_name 
simple_name1, _, _)) :: ( _, ( MlyValue.DEF DEF1, DEF1left, _)) :: 
rest671)) => let val  result = MlyValue.classifier_constraint_cs (fn _
 => let val  DEF1 = DEF1 ()
 val  (simple_name as simple_name1) = simple_name1 ()
 val  COLON1 = COLON1 ()
 val  (definition_constraint_cs as definition_constraint_cs1) = 
definition_constraint_cs1 ()
 in (SOME(simple_name),definition_constraint_cs)
end)
 in ( LrTable.NT 23, ( result, DEF1left, 
definition_constraint_cs1right), rest671)
end
|  ( 34, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.op_constraint_stereotype_cs 
op_constraint_stereotype_cs1, op_constraint_stereotype_cs1left, _)) ::
 rest671)) => let val  result = MlyValue.operation_constraint_cs (fn _
 => let val  (op_constraint_stereotype_cs as 
op_constraint_stereotype_cs1) = op_constraint_stereotype_cs1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (
Logger.debug3 ("operation_constraint_cs 1..." ^ "\n"); (op_constraint_stereotype_cs,NONE,ocl_expression_cs)
)
end)
 in ( LrTable.NT 26, ( result, op_constraint_stereotype_cs1left, 
ocl_expression_cs1right), rest671)
end
|  ( 35, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, ( 
MlyValue.op_constraint_stereotype_cs op_constraint_stereotype_cs1, 
op_constraint_stereotype_cs1left, _)) :: rest671)) => let val  result
 = MlyValue.operation_constraint_cs (fn _ => let val  (
op_constraint_stereotype_cs as op_constraint_stereotype_cs1) = 
op_constraint_stereotype_cs1 ()
 val  (simple_name as simple_name1) = simple_name1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (
Logger.debug3 ("operation_constraint_cs 23454..." ^ "\n"); (op_constraint_stereotype_cs,SOME(simple_name),ocl_expression_cs)
)
end)
 in ( LrTable.NT 26, ( result, op_constraint_stereotype_cs1left, 
ocl_expression_cs1right), rest671)
end
|  ( 36, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.GUARD GUARD1, GUARD1left, _)) :: rest671)) => let val  
result = MlyValue.guard_constraint_cs (fn _ => let val  GUARD1 = 
GUARD1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (NONE,ocl_expression_cs)
end)
 in ( LrTable.NT 28, ( result, GUARD1left, ocl_expression_cs1right), 
rest671)
end
|  ( 37, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.COLON COLON1, _, _)) :: (
 _, ( MlyValue.simple_name simple_name1, _, _)) :: ( _, ( 
MlyValue.GUARD GUARD1, GUARD1left, _)) :: rest671)) => let val  result
 = MlyValue.guard_constraint_cs (fn _ => let val  GUARD1 = GUARD1 ()
 val  (simple_name as simple_name1) = simple_name1 ()
 val  COLON1 = COLON1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (SOME(simple_name),ocl_expression_cs)
end)
 in ( LrTable.NT 28, ( result, GUARD1left, ocl_expression_cs1right), 
rest671)
end
|  ( 38, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.EQUALS EQUALS1, _, _)) ::
 ( _, ( MlyValue.defined_entity_decl_cs defined_entity_decl_cs1, 
defined_entity_decl_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.definition_constraint_cs (fn _ => let val  (
defined_entity_decl_cs as defined_entity_decl_cs1) = 
defined_entity_decl_cs1 ()
 val  (EQUALS as EQUALS1) = EQUALS1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (
OperationCall (defined_entity_decl_cs,DummyT,[OclLibPackage,"DummyT",EQUALS],[(ocl_expression_cs,DummyT)],DummyT)
)
end)
 in ( LrTable.NT 33, ( result, defined_entity_decl_cs1left, 
ocl_expression_cs1right), rest671)
end
|  ( 39, ( ( _, ( MlyValue.ocl_attribute_defined_entity_decl_cs 
ocl_attribute_defined_entity_decl_cs1, 
ocl_attribute_defined_entity_decl_cs1left, 
ocl_attribute_defined_entity_decl_cs1right)) :: rest671)) => let val  
result = MlyValue.defined_entity_decl_cs (fn _ => let val  (
ocl_attribute_defined_entity_decl_cs as 
ocl_attribute_defined_entity_decl_cs1) = 
ocl_attribute_defined_entity_decl_cs1 ()
 in (
Logger.debug3 ("AttributeCall 1 ..." ^ "\n");AttributeCall (Literal ("self2",DummyT),DummyT,[#1(ocl_attribute_defined_entity_decl_cs)],#2(ocl_attribute_defined_entity_decl_cs))
)
end)
 in ( LrTable.NT 34, ( result, 
ocl_attribute_defined_entity_decl_cs1left, 
ocl_attribute_defined_entity_decl_cs1right), rest671)
end
|  ( 40, ( ( _, ( MlyValue.ocl_operation_defined_entity_decl_cs 
ocl_operation_defined_entity_decl_cs1, 
ocl_operation_defined_entity_decl_cs1left, 
ocl_operation_defined_entity_decl_cs1right)) :: rest671)) => let val  
result = MlyValue.defined_entity_decl_cs (fn _ => let val  (
ocl_operation_defined_entity_decl_cs as 
ocl_operation_defined_entity_decl_cs1) = 
ocl_operation_defined_entity_decl_cs1 ()
 in (
OperationCall (Literal ("self2",DummyT),DummyT,[#1(ocl_operation_defined_entity_decl_cs)],List.map gen_literal_term (real_signature (#2(ocl_operation_defined_entity_decl_cs))),#2(List.last (#2(ocl_operation_defined_entity_decl_cs))))
)
end)
 in ( LrTable.NT 34, ( result, 
ocl_operation_defined_entity_decl_cs1left, 
ocl_operation_defined_entity_decl_cs1right), rest671)
end
|  ( 41, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
 let val  result = MlyValue.ocl_attribute_defined_entity_decl_cs (fn _
 => let val  (formal_parameter_cs as formal_parameter_cs1) = 
formal_parameter_cs1 ()
 in (formal_parameter_cs)
end)
 in ( LrTable.NT 35, ( result, formal_parameter_cs1left, 
formal_parameter_cs1right), rest671)
end
|  ( 42, ( ( _, ( MlyValue.operation_signature_cs 
operation_signature_cs1, _, operation_signature_cs1right)) :: ( _, ( 
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
 => let val  result = MlyValue.ocl_operation_defined_entity_decl_cs
 (fn _ => let val  (simple_name as simple_name1) = simple_name1 ()
 val  (operation_signature_cs as operation_signature_cs1) = 
operation_signature_cs1 ()
 in (simple_name,operation_signature_cs)
end)
 in ( LrTable.NT 36, ( result, simple_name1left, 
operation_signature_cs1right), rest671)
end
|  ( 43, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, 
PAREN_OPEN1left, _)) :: rest671)) => let val  result = 
MlyValue.operation_signature_cs (fn _ => let val  PAREN_OPEN1 = 
PAREN_OPEN1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Logger.debug3  ("operation_signature_cs ..." ^ "\n");[("",OclVoid)])

end)
 in ( LrTable.NT 24, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 44, ( ( _, ( MlyValue.operation_return_type_specifier_cs 
operation_return_type_specifier_cs1, _, 
operation_return_type_specifier_cs1right)) :: ( _, ( 
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, ( 
MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) =>
 let val  result = MlyValue.operation_signature_cs (fn _ => let val  
PAREN_OPEN1 = PAREN_OPEN1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 val  (operation_return_type_specifier_cs as 
operation_return_type_specifier_cs1) = 
operation_return_type_specifier_cs1 ()
 in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");[("",operation_return_type_specifier_cs)]
)
end)
 in ( LrTable.NT 24, ( result, PAREN_OPEN1left, 
operation_return_type_specifier_cs1right), rest671)
end
|  ( 45, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.formal_parameter_list_cs 
formal_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN 
PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) => let val  result = 
MlyValue.operation_signature_cs (fn _ => let val  PAREN_OPEN1 = 
PAREN_OPEN1 ()
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");formal_parameter_list_cs@[("",OclVoid)]
)
end)
 in ( LrTable.NT 24, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 46, ( ( _, ( MlyValue.operation_return_type_specifier_cs 
operation_return_type_specifier_cs1, _, 
operation_return_type_specifier_cs1right)) :: ( _, ( 
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, ( 
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
 ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) :: 
rest671)) => let val  result = MlyValue.operation_signature_cs (fn _
 => let val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 val  (operation_return_type_specifier_cs as 
operation_return_type_specifier_cs1) = 
operation_return_type_specifier_cs1 ()
 in (
Logger.debug3 ("operation_signature_cs ..." ^ "\n");formal_parameter_list_cs@[("",operation_return_type_specifier_cs)]
)
end)
 in ( LrTable.NT 24, ( result, PAREN_OPEN1left, 
operation_return_type_specifier_cs1right), rest671)
end
|  ( 47, ( ( _, ( MlyValue.type_specifier type_specifier1, _, 
type_specifier1right)) :: ( _, ( MlyValue.COLON COLON1, COLON1left, _)
) :: rest671)) => let val  result = 
MlyValue.operation_return_type_specifier_cs (fn _ => let val  COLON1 =
 COLON1 ()
 val  (type_specifier as type_specifier1) = type_specifier1 ()
 in (
Logger.debug3 ("Contextes created form list of Attributes ..." ^ "\n");type_specifier
)
end)
 in ( LrTable.NT 40, ( result, COLON1left, type_specifier1right), 
rest671)
end
|  ( 48, ( ( _, ( MlyValue.PRE PRE1, PRE1left, PRE1right)) :: rest671)
) => let val  result = MlyValue.op_constraint_stereotype_cs (fn _ =>
 let val  (PRE as PRE1) = PRE1 ()
 in (PRE)
end)
 in ( LrTable.NT 31, ( result, PRE1left, PRE1right), rest671)
end
|  ( 49, ( ( _, ( MlyValue.POST POST1, POST1left, POST1right)) :: 
rest671)) => let val  result = MlyValue.op_constraint_stereotype_cs
 (fn _ => let val  (POST as POST1) = POST1 ()
 in (POST)
end)
 in ( LrTable.NT 31, ( result, POST1left, POST1right), rest671)
end
|  ( 50, ( ( _, ( MlyValue.BODY BODY1, BODY1left, BODY1right)) :: 
rest671)) => let val  result = MlyValue.op_constraint_stereotype_cs
 (fn _ => let val  (BODY as BODY1) = BODY1 ()
 in (BODY)
end)
 in ( LrTable.NT 31, ( result, BODY1left, BODY1right), rest671)
end
|  ( 51, ( ( _, ( MlyValue.BRACE_CLOSE BRACE_CLOSE1, _, 
BRACE_CLOSE1right)) :: ( _, ( MlyValue.BRACE_OPEN BRACE_OPEN1, _, _))
 :: ( _, ( MlyValue.collection_type_identifier_cs 
collection_type_identifier_cs1, collection_type_identifier_cs1left, _)
) :: rest671)) => let val  result = MlyValue.collection_literal_exp_cs
 (fn _ => let val  (collection_type_identifier_cs as 
collection_type_identifier_cs1) = collection_type_identifier_cs1 ()
 val  BRACE_OPEN1 = BRACE_OPEN1 ()
 val  BRACE_CLOSE1 = BRACE_CLOSE1 ()
 in (
CollectionLiteral ([],create_set (collection_type_identifier_cs,DummyT))
)
end)
 in ( LrTable.NT 63, ( result, collection_type_identifier_cs1left, 
BRACE_CLOSE1right), rest671)
end
|  ( 52, ( ( _, ( MlyValue.BRACE_CLOSE BRACE_CLOSE1, _, 
BRACE_CLOSE1right)) :: ( _, ( MlyValue.collection_literal_parts_cs 
collection_literal_parts_cs1, _, _)) :: ( _, ( MlyValue.BRACE_OPEN 
BRACE_OPEN1, _, _)) :: ( _, ( MlyValue.collection_type_identifier_cs 
collection_type_identifier_cs1, collection_type_identifier_cs1left, _)
) :: rest671)) => let val  result = MlyValue.collection_literal_exp_cs
 (fn _ => let val  (collection_type_identifier_cs as 
collection_type_identifier_cs1) = collection_type_identifier_cs1 ()
 val  BRACE_OPEN1 = BRACE_OPEN1 ()
 val  (collection_literal_parts_cs as collection_literal_parts_cs1) = 
collection_literal_parts_cs1 ()
 val  BRACE_CLOSE1 = BRACE_CLOSE1 ()
 in (
CollectionLiteral (collection_literal_parts_cs,create_set(collection_type_identifier_cs,DummyT))
)
end)
 in ( LrTable.NT 63, ( result, collection_type_identifier_cs1left, 
BRACE_CLOSE1right), rest671)
end
|  ( 53, ( ( _, ( MlyValue.collection_literal_part_cs 
collection_literal_part_cs1, collection_literal_part_cs1left, 
collection_literal_part_cs1right)) :: rest671)) => let val  result = 
MlyValue.collection_literal_parts_cs (fn _ => let val  (
collection_literal_part_cs as collection_literal_part_cs1) = 
collection_literal_part_cs1 ()
 in ([collection_literal_part_cs])
end)
 in ( LrTable.NT 43, ( result, collection_literal_part_cs1left, 
collection_literal_part_cs1right), rest671)
end
|  ( 54, ( ( _, ( MlyValue.collection_literal_parts_tail_cs 
collection_literal_parts_tail_cs1, _, 
collection_literal_parts_tail_cs1right)) :: ( _, ( 
MlyValue.collection_literal_part_cs collection_literal_part_cs1, 
collection_literal_part_cs1left, _)) :: rest671)) => let val  result =
 MlyValue.collection_literal_parts_cs (fn _ => let val  (
collection_literal_part_cs as collection_literal_part_cs1) = 
collection_literal_part_cs1 ()
 val  (collection_literal_parts_tail_cs as 
collection_literal_parts_tail_cs1) = collection_literal_parts_tail_cs1
 ()
 in ([collection_literal_part_cs]@collection_literal_parts_tail_cs)

end)
 in ( LrTable.NT 43, ( result, collection_literal_part_cs1left, 
collection_literal_parts_tail_cs1right), rest671)
end
|  ( 55, ( ( _, ( MlyValue.collection_literal_parts_cs 
collection_literal_parts_cs1, _, collection_literal_parts_cs1right))
 :: ( _, ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let
 val  result = MlyValue.collection_literal_parts_tail_cs (fn _ => let
 val  COMMA1 = COMMA1 ()
 val  (collection_literal_parts_cs as collection_literal_parts_cs1) = 
collection_literal_parts_cs1 ()
 in (collection_literal_parts_cs)
end)
 in ( LrTable.NT 45, ( result, COMMA1left, 
collection_literal_parts_cs1right), rest671)
end
|  ( 56, ( ( _, ( MlyValue.collection_range_cs collection_range_cs1, 
collection_range_cs1left, collection_range_cs1right)) :: rest671)) =>
 let val  result = MlyValue.collection_literal_part_cs (fn _ => let
 val  (collection_range_cs as collection_range_cs1) = 
collection_range_cs1 ()
 in (collection_range_cs)
end)
 in ( LrTable.NT 44, ( result, collection_range_cs1left, 
collection_range_cs1right), rest671)
end
|  ( 57, ( ( _, ( MlyValue.expression expression1, expression1left, 
expression1right)) :: rest671)) => let val  result = 
MlyValue.collection_literal_part_cs (fn _ => let val  (expression as 
expression1) = expression1 ()
 in (CollectionItem (expression,DummyT))
end)
 in ( LrTable.NT 44, ( result, expression1left, expression1right), 
rest671)
end
|  ( 58, ( ( _, ( MlyValue.expression expression2, _, expression2right
)) :: ( _, ( MlyValue.DBL_DOT DBL_DOT1, _, _)) :: ( _, ( 
MlyValue.expression expression1, expression1left, _)) :: rest671)) =>
 let val  result = MlyValue.collection_range_cs (fn _ => let val  
expression1 = expression1 ()
 val  DBL_DOT1 = DBL_DOT1 ()
 val  expression2 = expression2 ()
 in (CollectionRange (expression1,expression2,DummyT))
end)
 in ( LrTable.NT 46, ( result, expression1left, expression2right), 
rest671)
end
|  ( 59, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.type_specifier type_specifier1,
 _, _)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.collection_type_identifier_cs collection_type_identifier_cs1,
 collection_type_identifier_cs1left, _)) :: rest671)) => let val  
result = MlyValue.collection_type_specifier_cs (fn _ => let val  (
collection_type_identifier_cs as collection_type_identifier_cs1) = 
collection_type_identifier_cs1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (type_specifier as type_specifier1) = type_specifier1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (create_set (collection_type_identifier_cs,type_specifier))
end)
 in ( LrTable.NT 48, ( result, collection_type_identifier_cs1left, 
PAREN_CLOSE1right), rest671)
end
|  ( 60, ( ( _, ( MlyValue.SET SET1, SET1left, SET1right)) :: rest671)
) => let val  result = MlyValue.collection_type_identifier_cs (fn _ =>
 let val  (SET as SET1) = SET1 ()
 in (SET)
end)
 in ( LrTable.NT 42, ( result, SET1left, SET1right), rest671)
end
|  ( 61, ( ( _, ( MlyValue.BAG BAG1, BAG1left, BAG1right)) :: rest671)
) => let val  result = MlyValue.collection_type_identifier_cs (fn _ =>
 let val  (BAG as BAG1) = BAG1 ()
 in (BAG)
end)
 in ( LrTable.NT 42, ( result, BAG1left, BAG1right), rest671)
end
|  ( 62, ( ( _, ( MlyValue.SEQUENCE SEQUENCE1, SEQUENCE1left, 
SEQUENCE1right)) :: rest671)) => let val  result = 
MlyValue.collection_type_identifier_cs (fn _ => let val  (SEQUENCE as 
SEQUENCE1) = SEQUENCE1 ()
 in (SEQUENCE)
end)
 in ( LrTable.NT 42, ( result, SEQUENCE1left, SEQUENCE1right), rest671
)
end
|  ( 63, ( ( _, ( MlyValue.COLLECTION COLLECTION1, COLLECTION1left, 
COLLECTION1right)) :: rest671)) => let val  result = 
MlyValue.collection_type_identifier_cs (fn _ => let val  (COLLECTION
 as COLLECTION1) = COLLECTION1 ()
 in (COLLECTION)
end)
 in ( LrTable.NT 42, ( result, COLLECTION1left, COLLECTION1right), 
rest671)
end
|  ( 64, ( ( _, ( MlyValue.ORDERED_SET ORDERED_SET1, ORDERED_SET1left,
 ORDERED_SET1right)) :: rest671)) => let val  result = 
MlyValue.collection_type_identifier_cs (fn _ => let val  (ORDERED_SET
 as ORDERED_SET1) = ORDERED_SET1 ()
 in (ORDERED_SET)
end)
 in ( LrTable.NT 42, ( result, ORDERED_SET1left, ORDERED_SET1right), 
rest671)
end
|  ( 65, ( ( _, ( MlyValue.is_marked_pre_cs is_marked_pre_cs1, 
is_marked_pre_cs1left, is_marked_pre_cs1right)) :: rest671)) => let
 val  result = MlyValue.time_exp_cs (fn _ => let val  (
is_marked_pre_cs as is_marked_pre_cs1) = is_marked_pre_cs1 ()
 in (is_marked_pre_cs)
end)
 in ( LrTable.NT 49, ( result, is_marked_pre_cs1left, 
is_marked_pre_cs1right), rest671)
end
|  ( 66, ( ( _, ( MlyValue.AT_PRE AT_PRE1, AT_PRE1left, AT_PRE1right))
 :: rest671)) => let val  result = MlyValue.is_marked_pre_cs (fn _ =>
 let val  (AT_PRE as AT_PRE1) = AT_PRE1 ()
 in (AT_PRE)
end)
 in ( LrTable.NT 50, ( result, AT_PRE1left, AT_PRE1right), rest671)

end
|  ( 67, ( ( _, ( MlyValue.logical_exp_cs logical_exp_cs1, 
logical_exp_cs1left, logical_exp_cs1right)) :: rest671)) => let val  
result = MlyValue.ocl_expression_cs (fn _ => let val  (logical_exp_cs
 as logical_exp_cs1) = logical_exp_cs1 ()
 in (Logger.debug3 ("ocl_expression_cs..." ^ "\n");logical_exp_cs)
end
)
 in ( LrTable.NT 54, ( result, logical_exp_cs1left, 
logical_exp_cs1right), rest671)
end
|  ( 68, ( ( _, ( MlyValue.let_exp_cs let_exp_cs1, let_exp_cs1left, 
let_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.ocl_expression_cs (fn _ => let val  (let_exp_cs as 
let_exp_cs1) = let_exp_cs1 ()
 in (Logger.debug3 ("ocl_expression_cs..." ^ "\n");let_exp_cs)
end)
 in ( LrTable.NT 54, ( result, let_exp_cs1left, let_exp_cs1right), 
rest671)
end
|  ( 69, ( ( _, ( MlyValue.expression expression1, _, expression1right
)) :: ( _, ( MlyValue.IN IN1, _, _)) :: ( _, ( 
MlyValue.initialized_variable_list_cs initialized_variable_list_cs1, _
, _)) :: ( _, ( MlyValue.LET LET1, LET1left, _)) :: rest671)) => let
 val  result = MlyValue.let_exp_cs (fn _ => let val  LET1 = LET1 ()
 val  (initialized_variable_list_cs as initialized_variable_list_cs1)
 = initialized_variable_list_cs1 ()
 val  IN1 = IN1 ()
 val  (expression as expression1) = expression1 ()
 in (gen_let_term initialized_variable_list_cs expression)
end)
 in ( LrTable.NT 55, ( result, LET1left, expression1right), rest671)

end
|  ( 70, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, 
ocl_expression_cs1left, ocl_expression_cs1right)) :: rest671)) => let
 val  result = MlyValue.expression (fn _ => let val  (
ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1 ()
 in (ocl_expression_cs)
end)
 in ( LrTable.NT 47, ( result, ocl_expression_cs1left, 
ocl_expression_cs1right), rest671)
end
|  ( 71, ( ( _, ( MlyValue.SELECT SELECT1, SELECT1left, SELECT1right))
 :: rest671)) => let val  result = MlyValue.iterator_name_cs (fn _ =>
 let val  (SELECT as SELECT1) = SELECT1 ()
 in (SELECT)
end)
 in ( LrTable.NT 60, ( result, SELECT1left, SELECT1right), rest671)

end
|  ( 72, ( ( _, ( MlyValue.REJECT REJECT1, REJECT1left, REJECT1right))
 :: rest671)) => let val  result = MlyValue.iterator_name_cs (fn _ =>
 let val  (REJECT as REJECT1) = REJECT1 ()
 in (REJECT)
end)
 in ( LrTable.NT 60, ( result, REJECT1left, REJECT1right), rest671)

end
|  ( 73, ( ( _, ( MlyValue.COLLECT COLLECT1, COLLECT1left, 
COLLECT1right)) :: rest671)) => let val  result = 
MlyValue.iterator_name_cs (fn _ => let val  (COLLECT as COLLECT1) = 
COLLECT1 ()
 in (COLLECT)
end)
 in ( LrTable.NT 60, ( result, COLLECT1left, COLLECT1right), rest671)

end
|  ( 74, ( ( _, ( MlyValue.FORALL FORALL1, FORALL1left, FORALL1right))
 :: rest671)) => let val  result = MlyValue.iterator_name_cs (fn _ =>
 let val  (FORALL as FORALL1) = FORALL1 ()
 in (FORALL)
end)
 in ( LrTable.NT 60, ( result, FORALL1left, FORALL1right), rest671)

end
|  ( 75, ( ( _, ( MlyValue.EXISTS EXISTS1, EXISTS1left, EXISTS1right))
 :: rest671)) => let val  result = MlyValue.iterator_name_cs (fn _ =>
 let val  (EXISTS as EXISTS1) = EXISTS1 ()
 in (EXISTS)
end)
 in ( LrTable.NT 60, ( result, EXISTS1left, EXISTS1right), rest671)

end
|  ( 76, ( ( _, ( MlyValue.ANY ANY1, ANY1left, ANY1right)) :: rest671)
) => let val  result = MlyValue.iterator_name_cs (fn _ => let val  (
ANY as ANY1) = ANY1 ()
 in (ANY)
end)
 in ( LrTable.NT 60, ( result, ANY1left, ANY1right), rest671)
end
|  ( 77, ( ( _, ( MlyValue.ONE ONE1, ONE1left, ONE1right)) :: rest671)
) => let val  result = MlyValue.iterator_name_cs (fn _ => let val  (
ONE as ONE1) = ONE1 ()
 in (ONE)
end)
 in ( LrTable.NT 60, ( result, ONE1left, ONE1right), rest671)
end
|  ( 78, ( ( _, ( MlyValue.ISUNIQUE ISUNIQUE1, ISUNIQUE1left, 
ISUNIQUE1right)) :: rest671)) => let val  result = 
MlyValue.iterator_name_cs (fn _ => let val  (ISUNIQUE as ISUNIQUE1) = 
ISUNIQUE1 ()
 in (ISUNIQUE)
end)
 in ( LrTable.NT 60, ( result, ISUNIQUE1left, ISUNIQUE1right), rest671
)
end
|  ( 79, ( ( _, ( MlyValue.OCLISKINDOF OCLISKINDOF1, OCLISKINDOF1left,
 OCLISKINDOF1right)) :: rest671)) => let val  result = 
MlyValue.ocl_op_name (fn _ => let val  (OCLISKINDOF as OCLISKINDOF1) =
 OCLISKINDOF1 ()
 in (OCLISKINDOF)
end)
 in ( LrTable.NT 61, ( result, OCLISKINDOF1left, OCLISKINDOF1right), 
rest671)
end
|  ( 80, ( ( _, ( MlyValue.OCLISTYPEOF OCLISTYPEOF1, OCLISTYPEOF1left,
 OCLISTYPEOF1right)) :: rest671)) => let val  result = 
MlyValue.ocl_op_name (fn _ => let val  (OCLISTYPEOF as OCLISTYPEOF1) =
 OCLISTYPEOF1 ()
 in (OCLISTYPEOF)
end)
 in ( LrTable.NT 61, ( result, OCLISTYPEOF1left, OCLISTYPEOF1right), 
rest671)
end
|  ( 81, ( ( _, ( MlyValue.OCLASTYPE OCLASTYPE1, OCLASTYPE1left, 
OCLASTYPE1right)) :: rest671)) => let val  result = 
MlyValue.ocl_op_name (fn _ => let val  (OCLASTYPE as OCLASTYPE1) = 
OCLASTYPE1 ()
 in (OCLASTYPE)
end)
 in ( LrTable.NT 61, ( result, OCLASTYPE1left, OCLASTYPE1right), 
rest671)
end
|  ( 82, ( ( _, ( MlyValue.identifier_cs identifier_cs1, 
identifier_cs1left, identifier_cs1right)) :: rest671)) => let val  
result = MlyValue.path_name_cs (fn _ => let val  (identifier_cs as 
identifier_cs1) = identifier_cs1 ()
 in (Logger.debug3 ("path_name finished..." ^ "\n");[identifier_cs])

end)
 in ( LrTable.NT 11, ( result, identifier_cs1left, identifier_cs1right
), rest671)
end
|  ( 83, ( ( _, ( MlyValue.identifier_cs identifier_cs1, _, 
identifier_cs1right)) :: ( _, ( MlyValue.path_name_head_cs 
path_name_head_cs1, path_name_head_cs1left, _)) :: rest671)) => let
 val  result = MlyValue.path_name_cs (fn _ => let val  (
path_name_head_cs as path_name_head_cs1) = path_name_head_cs1 ()
 val  (identifier_cs as identifier_cs1) = identifier_cs1 ()
 in (
Logger.debug3 ("path_name generation ..." ^ "\n");path_name_head_cs@[identifier_cs]
)
end)
 in ( LrTable.NT 11, ( result, path_name_head_cs1left, 
identifier_cs1right), rest671)
end
|  ( 84, ( ( _, ( MlyValue.simple_name simple_name1, simple_name1left,
 simple_name1right)) :: rest671)) => let val  result = 
MlyValue.identifier_cs (fn _ => let val  (simple_name as simple_name1)
 = simple_name1 ()
 in (Logger.debug3 ("path_name generation..." ^ "\n");simple_name)
end
)
 in ( LrTable.NT 59, ( result, simple_name1left, simple_name1right), 
rest671)
end
|  ( 85, ( ( _, ( MlyValue.ITERATE ITERATE1, ITERATE1left, 
ITERATE1right)) :: rest671)) => let val  result = 
MlyValue.identifier_cs (fn _ => let val  (ITERATE as ITERATE1) = 
ITERATE1 ()
 in (ITERATE)
end)
 in ( LrTable.NT 59, ( result, ITERATE1left, ITERATE1right), rest671)

end
|  ( 86, ( ( _, ( MlyValue.iterator_name_cs iterator_name_cs1, 
iterator_name_cs1left, iterator_name_cs1right)) :: rest671)) => let
 val  result = MlyValue.identifier_cs (fn _ => let val  (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
 in (iterator_name_cs)
end)
 in ( LrTable.NT 59, ( result, iterator_name_cs1left, 
iterator_name_cs1right), rest671)
end
|  ( 87, ( ( _, ( MlyValue.ocl_op_name ocl_op_name1, ocl_op_name1left,
 ocl_op_name1right)) :: rest671)) => let val  result = 
MlyValue.identifier_cs (fn _ => let val  (ocl_op_name as ocl_op_name1)
 = ocl_op_name1 ()
 in (ocl_op_name)
end)
 in ( LrTable.NT 59, ( result, ocl_op_name1left, ocl_op_name1right), 
rest671)
end
|  ( 88, ( ( _, ( MlyValue.DBL_COLON DBL_COLON1, _, DBL_COLON1right))
 :: ( _, ( MlyValue.identifier_cs identifier_cs1, identifier_cs1left,
 _)) :: rest671)) => let val  result = MlyValue.path_name_head_cs (fn
 _ => let val  (identifier_cs as identifier_cs1) = identifier_cs1 ()
 val  DBL_COLON1 = DBL_COLON1 ()
 in (Logger.debug3 ("path_name generation..." ^ "\n");[identifier_cs])

end)
 in ( LrTable.NT 12, ( result, identifier_cs1left, DBL_COLON1right), 
rest671)
end
|  ( 89, ( ( _, ( MlyValue.DBL_COLON DBL_COLON1, _, DBL_COLON1right))
 :: ( _, ( MlyValue.identifier_cs identifier_cs1, _, _)) :: ( _, ( 
MlyValue.path_name_head_cs path_name_head_cs1, path_name_head_cs1left,
 _)) :: rest671)) => let val  result = MlyValue.path_name_head_cs (fn
 _ => let val  (path_name_head_cs as path_name_head_cs1) = 
path_name_head_cs1 ()
 val  (identifier_cs as identifier_cs1) = identifier_cs1 ()
 val  DBL_COLON1 = DBL_COLON1 ()
 in (
Logger.debug3 ("path_name generation..." ^ "\n");path_name_head_cs@[identifier_cs]
)
end)
 in ( LrTable.NT 12, ( result, path_name_head_cs1left, DBL_COLON1right
), rest671)
end
|  ( 90, ( ( _, ( MlyValue.primitive_literal_exp_cs 
primitive_literal_exp_cs1, primitive_literal_exp_cs1left, 
primitive_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.literal_exp_cs (fn _ => let val  (primitive_literal_exp_cs
 as primitive_literal_exp_cs1) = primitive_literal_exp_cs1 ()
 in (
Logger.debug3 ("primitive_literal_exp_cs..." ^ "\n");primitive_literal_exp_cs
)
end)
 in ( LrTable.NT 62, ( result, primitive_literal_exp_cs1left, 
primitive_literal_exp_cs1right), rest671)
end
|  ( 91, ( ( _, ( MlyValue.collection_literal_exp_cs 
collection_literal_exp_cs1, collection_literal_exp_cs1left, 
collection_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.literal_exp_cs (fn _ => let val  (collection_literal_exp_cs
 as collection_literal_exp_cs1) = collection_literal_exp_cs1 ()
 in (collection_literal_exp_cs)
end)
 in ( LrTable.NT 62, ( result, collection_literal_exp_cs1left, 
collection_literal_exp_cs1right), rest671)
end
|  ( 92, ( ( _, ( MlyValue.numeric_literal_exp_cs 
numeric_literal_exp_cs1, numeric_literal_exp_cs1left, 
numeric_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.primitive_literal_exp_cs (fn _ => let val  (
numeric_literal_exp_cs as numeric_literal_exp_cs1) = 
numeric_literal_exp_cs1 ()
 in (
Logger.debug3 ("numeric_literal_exp_cs..." ^ "\n");numeric_literal_exp_cs
)
end)
 in ( LrTable.NT 65, ( result, numeric_literal_exp_cs1left, 
numeric_literal_exp_cs1right), rest671)
end
|  ( 93, ( ( _, ( MlyValue.string_literal_exp_cs 
string_literal_exp_cs1, string_literal_exp_cs1left, 
string_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.primitive_literal_exp_cs (fn _ => let val  (
string_literal_exp_cs as string_literal_exp_cs1) = 
string_literal_exp_cs1 ()
 in (
Logger.debug3 ("string_literal_exp_cs..." ^ "\n");string_literal_exp_cs
)
end)
 in ( LrTable.NT 65, ( result, string_literal_exp_cs1left, 
string_literal_exp_cs1right), rest671)
end
|  ( 94, ( ( _, ( MlyValue.boolean_literal_exp_cs 
boolean_literal_exp_cs1, boolean_literal_exp_cs1left, 
boolean_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.primitive_literal_exp_cs (fn _ => let val  (
boolean_literal_exp_cs as boolean_literal_exp_cs1) = 
boolean_literal_exp_cs1 ()
 in (boolean_literal_exp_cs)
end)
 in ( LrTable.NT 65, ( result, boolean_literal_exp_cs1left, 
boolean_literal_exp_cs1right), rest671)
end
|  ( 95, ( ( _, ( MlyValue.invalid_literal_exp_cs 
invalid_literal_exp_cs1, invalid_literal_exp_cs1left, 
invalid_literal_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.primitive_literal_exp_cs (fn _ => let val  (
invalid_literal_exp_cs as invalid_literal_exp_cs1) = 
invalid_literal_exp_cs1 ()
 in (invalid_literal_exp_cs)
end)
 in ( LrTable.NT 65, ( result, invalid_literal_exp_cs1left, 
invalid_literal_exp_cs1right), rest671)
end
|  ( 96, ( ( _, ( MlyValue.INTEGER_LITERAL INTEGER_LITERAL1, 
INTEGER_LITERAL1left, INTEGER_LITERAL1right)) :: rest671)) => let val 
 result = MlyValue.numeric_literal_exp_cs (fn _ => let val  (
INTEGER_LITERAL as INTEGER_LITERAL1) = INTEGER_LITERAL1 ()
 in (
Logger.debug3 ("INTEGER_LITERAL..." ^ "\n");Literal (INTEGER_LITERAL,Integer)
)
end)
 in ( LrTable.NT 66, ( result, INTEGER_LITERAL1left, 
INTEGER_LITERAL1right), rest671)
end
|  ( 97, ( ( _, ( MlyValue.REAL_LITERAL REAL_LITERAL1, 
REAL_LITERAL1left, REAL_LITERAL1right)) :: rest671)) => let val  
result = MlyValue.numeric_literal_exp_cs (fn _ => let val  (
REAL_LITERAL as REAL_LITERAL1) = REAL_LITERAL1 ()
 in (Literal (REAL_LITERAL,Real))
end)
 in ( LrTable.NT 66, ( result, REAL_LITERAL1left, REAL_LITERAL1right),
 rest671)
end
|  ( 98, ( ( _, ( MlyValue.STRING_LITERAL STRING_LITERAL1, 
STRING_LITERAL1left, STRING_LITERAL1right)) :: rest671)) => let val  
result = MlyValue.string_literal_exp_cs (fn _ => let val  (
STRING_LITERAL as STRING_LITERAL1) = STRING_LITERAL1 ()
 in (Literal (STRING_LITERAL,String))
end)
 in ( LrTable.NT 67, ( result, STRING_LITERAL1left, 
STRING_LITERAL1right), rest671)
end
|  ( 99, ( ( _, ( MlyValue.TRUE TRUE1, TRUE1left, TRUE1right)) :: 
rest671)) => let val  result = MlyValue.boolean_literal_exp_cs (fn _
 => let val  TRUE1 = TRUE1 ()
 in (Literal ("true",Boolean))
end)
 in ( LrTable.NT 68, ( result, TRUE1left, TRUE1right), rest671)
end
|  ( 100, ( ( _, ( MlyValue.FALSE FALSE1, FALSE1left, FALSE1right)) ::
 rest671)) => let val  result = MlyValue.boolean_literal_exp_cs (fn _
 => let val  FALSE1 = FALSE1 ()
 in (Literal ("false",Boolean))
end)
 in ( LrTable.NT 68, ( result, FALSE1left, FALSE1right), rest671)
end
|  ( 101, ( ( _, ( MlyValue.NULL NULL1, NULL1left, NULL1right)) :: 
rest671)) => let val  result = MlyValue.invalid_literal_exp_cs (fn _
 => let val  NULL1 = NULL1 ()
 in (Literal ("null",DummyT))
end)
 in ( LrTable.NT 69, ( result, NULL1left, NULL1right), rest671)
end
|  ( 102, ( ( _, ( MlyValue.relational_exp_cs relational_exp_cs1, 
relational_exp_cs1left, relational_exp_cs1right)) :: rest671)) => let
 val  result = MlyValue.logical_exp_cs (fn _ => let val  (
relational_exp_cs as relational_exp_cs1) = relational_exp_cs1 ()
 in (Logger.debug3 ("logical_exp_cs..." ^ "\n");relational_exp_cs)
end
)
 in ( LrTable.NT 74, ( result, relational_exp_cs1left, 
relational_exp_cs1right), rest671)
end
|  ( 103, ( ( _, ( MlyValue.logical_exp_tail_cs_p 
logical_exp_tail_cs_p1, _, logical_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.relational_exp_cs relational_exp_cs1, relational_exp_cs1left,
 _)) :: rest671)) => let val  result = MlyValue.logical_exp_cs (fn _
 => let val  (relational_exp_cs as relational_exp_cs1) = 
relational_exp_cs1 ()
 val  (logical_exp_tail_cs_p as logical_exp_tail_cs_p1) = 
logical_exp_tail_cs_p1 ()
 in (
Logger.debug3 ("logical_exp_cs..." ^ "\n");OperationCall(relational_exp_cs,Boolean,[OclLibPackage,"Boolean",#1(logical_exp_tail_cs_p)],[(#2(logical_exp_tail_cs_p),Boolean)],Boolean)
)
end)
 in ( LrTable.NT 74, ( result, relational_exp_cs1left, 
logical_exp_tail_cs_p1right), rest671)
end
|  ( 104, ( ( _, ( MlyValue.logical_exp_tail_cs logical_exp_tail_cs1, 
logical_exp_tail_cs1left, logical_exp_tail_cs1right)) :: rest671)) =>
 let val  result = MlyValue.logical_exp_tail_cs_p (fn _ => let val  (
logical_exp_tail_cs as logical_exp_tail_cs1) = logical_exp_tail_cs1 ()
 in (logical_exp_tail_cs)
end)
 in ( LrTable.NT 115, ( result, logical_exp_tail_cs1left, 
logical_exp_tail_cs1right), rest671)
end
|  ( 105, ( ( _, ( MlyValue.logical_exp_tail_cs_p 
logical_exp_tail_cs_p1, _, logical_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.logical_exp_tail_cs logical_exp_tail_cs1, 
logical_exp_tail_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.logical_exp_tail_cs_p (fn _ => let val  (logical_exp_tail_cs
 as logical_exp_tail_cs1) = logical_exp_tail_cs1 ()
 val  (logical_exp_tail_cs_p as logical_exp_tail_cs_p1) = 
logical_exp_tail_cs_p1 ()
 in (
(#1(logical_exp_tail_cs),OperationCall(#2(logical_exp_tail_cs),Boolean,[OclLibPackage,"Boolean",#1(logical_exp_tail_cs_p)],[(#2(logical_exp_tail_cs_p),Boolean)],Boolean))
)
end)
 in ( LrTable.NT 115, ( result, logical_exp_tail_cs1left, 
logical_exp_tail_cs_p1right), rest671)
end
|  ( 106, ( ( _, ( MlyValue.relational_exp_cs relational_exp_cs1, _, 
relational_exp_cs1right)) :: ( _, ( MlyValue.logic_op logic_op1, 
logic_op1left, _)) :: rest671)) => let val  result = 
MlyValue.logical_exp_tail_cs (fn _ => let val  (logic_op as logic_op1)
 = logic_op1 ()
 val  (relational_exp_cs as relational_exp_cs1) = relational_exp_cs1
 ()
 in (logic_op,relational_exp_cs)
end)
 in ( LrTable.NT 75, ( result, logic_op1left, relational_exp_cs1right)
, rest671)
end
|  ( 107, ( ( _, ( MlyValue.LOG_AND LOG_AND1, LOG_AND1left, 
LOG_AND1right)) :: rest671)) => let val  result = MlyValue.logic_op
 (fn _ => let val  (LOG_AND as LOG_AND1) = LOG_AND1 ()
 in (LOG_AND)
end)
 in ( LrTable.NT 79, ( result, LOG_AND1left, LOG_AND1right), rest671)

end
|  ( 108, ( ( _, ( MlyValue.LOG_OR LOG_OR1, LOG_OR1left, LOG_OR1right)
) :: rest671)) => let val  result = MlyValue.logic_op (fn _ => let
 val  (LOG_OR as LOG_OR1) = LOG_OR1 ()
 in (LOG_OR)
end)
 in ( LrTable.NT 79, ( result, LOG_OR1left, LOG_OR1right), rest671)

end
|  ( 109, ( ( _, ( MlyValue.LOG_XOR LOG_XOR1, LOG_XOR1left, 
LOG_XOR1right)) :: rest671)) => let val  result = MlyValue.logic_op
 (fn _ => let val  (LOG_XOR as LOG_XOR1) = LOG_XOR1 ()
 in (LOG_XOR)
end)
 in ( LrTable.NT 79, ( result, LOG_XOR1left, LOG_XOR1right), rest671)

end
|  ( 110, ( ( _, ( MlyValue.LOG_IMPL LOG_IMPL1, LOG_IMPL1left, 
LOG_IMPL1right)) :: rest671)) => let val  result = MlyValue.logic_op
 (fn _ => let val  (LOG_IMPL as LOG_IMPL1) = LOG_IMPL1 ()
 in (LOG_IMPL)
end)
 in ( LrTable.NT 79, ( result, LOG_IMPL1left, LOG_IMPL1right), rest671
)
end
|  ( 111, ( ( _, ( MlyValue.additive_exp_cs additive_exp_cs1, 
additive_exp_cs1left, additive_exp_cs1right)) :: rest671)) => let val 
 result = MlyValue.relational_exp_cs (fn _ => let val  (
additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
 in (Logger.debug3 ("additive_exp_cs..." ^ "\n");additive_exp_cs)
end)
 in ( LrTable.NT 76, ( result, additive_exp_cs1left, 
additive_exp_cs1right), rest671)
end
|  ( 112, ( ( _, ( MlyValue.relational_exp_tail_cs 
relational_exp_tail_cs1, _, relational_exp_tail_cs1right)) :: ( _, ( 
MlyValue.additive_exp_cs additive_exp_cs1, additive_exp_cs1left, _))
 :: rest671)) => let val  result = MlyValue.relational_exp_cs (fn _ =>
 let val  (additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
 val  (relational_exp_tail_cs as relational_exp_tail_cs1) = 
relational_exp_tail_cs1 ()
 in (
Logger.debug3 ("additive_exp_cs relational_exp_tail_cs ..." ^ "\n");OperationCall(additive_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(relational_exp_tail_cs)],[(#2(relational_exp_tail_cs),DummyT)],Boolean)
)
end)
 in ( LrTable.NT 76, ( result, additive_exp_cs1left, 
relational_exp_tail_cs1right), rest671)
end
|  ( 113, ( ( _, ( MlyValue.additive_exp_cs additive_exp_cs1, _, 
additive_exp_cs1right)) :: ( _, ( MlyValue.rel_op rel_op1, rel_op1left
, _)) :: rest671)) => let val  result = 
MlyValue.relational_exp_tail_cs (fn _ => let val  (rel_op as rel_op1)
 = rel_op1 ()
 val  (additive_exp_cs as additive_exp_cs1) = additive_exp_cs1 ()
 in (
Logger.debug3 ("relational_exp_tail_cs..." ^ "\n");(rel_op, additive_exp_cs)
)
end)
 in ( LrTable.NT 78, ( result, rel_op1left, additive_exp_cs1right), 
rest671)
end
|  ( 114, ( ( _, ( MlyValue.EQUALS EQUALS1, EQUALS1left, EQUALS1right)
) :: rest671)) => let val  result = MlyValue.rel_op (fn _ => let val 
 (EQUALS as EQUALS1) = EQUALS1 ()
 in (EQUALS)
end)
 in ( LrTable.NT 83, ( result, EQUALS1left, EQUALS1right), rest671)

end
|  ( 115, ( ( _, ( MlyValue.REL_GT REL_GT1, REL_GT1left, REL_GT1right)
) :: rest671)) => let val  result = MlyValue.rel_op (fn _ => let val 
 (REL_GT as REL_GT1) = REL_GT1 ()
 in (Logger.debug3 (">..." ^ "\n");REL_GT)
end)
 in ( LrTable.NT 83, ( result, REL_GT1left, REL_GT1right), rest671)

end
|  ( 116, ( ( _, ( MlyValue.REL_LT REL_LT1, REL_LT1left, REL_LT1right)
) :: rest671)) => let val  result = MlyValue.rel_op (fn _ => let val 
 (REL_LT as REL_LT1) = REL_LT1 ()
 in (Logger.debug3 ("<..." ^ "\n");REL_LT)
end)
 in ( LrTable.NT 83, ( result, REL_LT1left, REL_LT1right), rest671)

end
|  ( 117, ( ( _, ( MlyValue.REL_GTE REL_GTE1, REL_GTE1left, 
REL_GTE1right)) :: rest671)) => let val  result = MlyValue.rel_op (fn
 _ => let val  (REL_GTE as REL_GTE1) = REL_GTE1 ()
 in (REL_GTE)
end)
 in ( LrTable.NT 83, ( result, REL_GTE1left, REL_GTE1right), rest671)

end
|  ( 118, ( ( _, ( MlyValue.REL_LTE REL_LTE1, REL_LTE1left, 
REL_LTE1right)) :: rest671)) => let val  result = MlyValue.rel_op (fn
 _ => let val  (REL_LTE as REL_LTE1) = REL_LTE1 ()
 in (REL_LTE)
end)
 in ( LrTable.NT 83, ( result, REL_LTE1left, REL_LTE1right), rest671)

end
|  ( 119, ( ( _, ( MlyValue.REL_NOTEQUAL REL_NOTEQUAL1, 
REL_NOTEQUAL1left, REL_NOTEQUAL1right)) :: rest671)) => let val  
result = MlyValue.rel_op (fn _ => let val  (REL_NOTEQUAL as 
REL_NOTEQUAL1) = REL_NOTEQUAL1 ()
 in (REL_NOTEQUAL)
end)
 in ( LrTable.NT 83, ( result, REL_NOTEQUAL1left, REL_NOTEQUAL1right),
 rest671)
end
|  ( 120, ( ( _, ( MlyValue.multiplicative_exp_cs 
multiplicative_exp_cs1, multiplicative_exp_cs1left, 
multiplicative_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.additive_exp_cs (fn _ => let val  (multiplicative_exp_cs as 
multiplicative_exp_cs1) = multiplicative_exp_cs1 ()
 in (
Logger.debug3 ("multiplicative_exp_cs..." ^ "\n");multiplicative_exp_cs
)
end)
 in ( LrTable.NT 80, ( result, multiplicative_exp_cs1left, 
multiplicative_exp_cs1right), rest671)
end
|  ( 121, ( ( _, ( MlyValue.additive_exp_tail_cs_p 
additive_exp_tail_cs_p1, _, additive_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.multiplicative_exp_cs multiplicative_exp_cs1, 
multiplicative_exp_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.additive_exp_cs (fn _ => let val  (multiplicative_exp_cs as 
multiplicative_exp_cs1) = multiplicative_exp_cs1 ()
 val  (additive_exp_tail_cs_p as additive_exp_tail_cs_p1) = 
additive_exp_tail_cs_p1 ()
 in (
Logger.debug3 ("multiplicative_exp_cs additive_exp_tail_cs_p..." ^ "\n");OperationCall (multiplicative_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(additive_exp_tail_cs_p)],[(#2(additive_exp_tail_cs_p),DummyT)],DummyT)
)
end)
 in ( LrTable.NT 80, ( result, multiplicative_exp_cs1left, 
additive_exp_tail_cs_p1right), rest671)
end
|  ( 122, ( ( _, ( MlyValue.additive_exp_tail_cs additive_exp_tail_cs1
, additive_exp_tail_cs1left, additive_exp_tail_cs1right)) :: rest671))
 => let val  result = MlyValue.additive_exp_tail_cs_p (fn _ => let
 val  (additive_exp_tail_cs as additive_exp_tail_cs1) = 
additive_exp_tail_cs1 ()
 in (additive_exp_tail_cs)
end)
 in ( LrTable.NT 82, ( result, additive_exp_tail_cs1left, 
additive_exp_tail_cs1right), rest671)
end
|  ( 123, ( ( _, ( MlyValue.additive_exp_tail_cs_p 
additive_exp_tail_cs_p1, _, additive_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.additive_exp_tail_cs additive_exp_tail_cs1, 
additive_exp_tail_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.additive_exp_tail_cs_p (fn _ => let val  (
additive_exp_tail_cs as additive_exp_tail_cs1) = additive_exp_tail_cs1
 ()
 val  (additive_exp_tail_cs_p as additive_exp_tail_cs_p1) = 
additive_exp_tail_cs_p1 ()
 in (
#1(additive_exp_tail_cs),OperationCall (#2(additive_exp_tail_cs),DummyT,[OclLibPackage,"DummyT",#1(additive_exp_tail_cs_p)],[(#2(additive_exp_tail_cs_p),DummyT)],DummyT)
)
end)
 in ( LrTable.NT 82, ( result, additive_exp_tail_cs1left, 
additive_exp_tail_cs_p1right), rest671)
end
|  ( 124, ( ( _, ( MlyValue.multiplicative_exp_cs 
multiplicative_exp_cs1, _, multiplicative_exp_cs1right)) :: ( _, ( 
MlyValue.add_op add_op1, add_op1left, _)) :: rest671)) => let val  
result = MlyValue.additive_exp_tail_cs (fn _ => let val  (add_op as 
add_op1) = add_op1 ()
 val  (multiplicative_exp_cs as multiplicative_exp_cs1) = 
multiplicative_exp_cs1 ()
 in (add_op, multiplicative_exp_cs)
end)
 in ( LrTable.NT 81, ( result, add_op1left, 
multiplicative_exp_cs1right), rest671)
end
|  ( 125, ( ( _, ( MlyValue.PLUS PLUS1, PLUS1left, PLUS1right)) :: 
rest671)) => let val  result = MlyValue.add_op (fn _ => let val  (PLUS
 as PLUS1) = PLUS1 ()
 in (PLUS)
end)
 in ( LrTable.NT 87, ( result, PLUS1left, PLUS1right), rest671)
end
|  ( 126, ( ( _, ( MlyValue.MINUS MINUS1, MINUS1left, MINUS1right)) ::
 rest671)) => let val  result = MlyValue.add_op (fn _ => let val  (
MINUS as MINUS1) = MINUS1 ()
 in (MINUS)
end)
 in ( LrTable.NT 87, ( result, MINUS1left, MINUS1right), rest671)
end
|  ( 127, ( ( _, ( MlyValue.unary_exp_cs unary_exp_cs1, 
unary_exp_cs1left, unary_exp_cs1right)) :: rest671)) => let val  
result = MlyValue.multiplicative_exp_cs (fn _ => let val  (
unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
 in (Logger.debug3 ("unary_exp_cs ..." ^ "\n");unary_exp_cs)
end)
 in ( LrTable.NT 84, ( result, unary_exp_cs1left, unary_exp_cs1right),
 rest671)
end
|  ( 128, ( ( _, ( MlyValue.multiplicative_exp_tail_cs_p 
multiplicative_exp_tail_cs_p1, _, multiplicative_exp_tail_cs_p1right))
 :: ( _, ( MlyValue.unary_exp_cs unary_exp_cs1, unary_exp_cs1left, _))
 :: rest671)) => let val  result = MlyValue.multiplicative_exp_cs (fn
 _ => let val  (unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
 val  (multiplicative_exp_tail_cs_p as multiplicative_exp_tail_cs_p1)
 = multiplicative_exp_tail_cs_p1 ()
 in (
OperationCall (unary_exp_cs,DummyT,[OclLibPackage,"DummyT",#1(multiplicative_exp_tail_cs_p)],[(#2(multiplicative_exp_tail_cs_p),DummyT)],DummyT)
)
end)
 in ( LrTable.NT 84, ( result, unary_exp_cs1left, 
multiplicative_exp_tail_cs_p1right), rest671)
end
|  ( 129, ( ( _, ( MlyValue.multiplicative_exp_tail_cs 
multiplicative_exp_tail_cs1, multiplicative_exp_tail_cs1left, 
multiplicative_exp_tail_cs1right)) :: rest671)) => let val  result = 
MlyValue.multiplicative_exp_tail_cs_p (fn _ => let val  (
multiplicative_exp_tail_cs as multiplicative_exp_tail_cs1) = 
multiplicative_exp_tail_cs1 ()
 in (multiplicative_exp_tail_cs)
end)
 in ( LrTable.NT 85, ( result, multiplicative_exp_tail_cs1left, 
multiplicative_exp_tail_cs1right), rest671)
end
|  ( 130, ( ( _, ( MlyValue.multiplicative_exp_tail_cs_p 
multiplicative_exp_tail_cs_p1, _, multiplicative_exp_tail_cs_p1right))
 :: ( _, ( MlyValue.multiplicative_exp_tail_cs 
multiplicative_exp_tail_cs1, multiplicative_exp_tail_cs1left, _)) :: 
rest671)) => let val  result = MlyValue.multiplicative_exp_tail_cs_p
 (fn _ => let val  (multiplicative_exp_tail_cs as 
multiplicative_exp_tail_cs1) = multiplicative_exp_tail_cs1 ()
 val  (multiplicative_exp_tail_cs_p as multiplicative_exp_tail_cs_p1)
 = multiplicative_exp_tail_cs_p1 ()
 in (
#1(multiplicative_exp_tail_cs),OperationCall (#2(multiplicative_exp_tail_cs),DummyT,[OclLibPackage,"DummyT",#1(multiplicative_exp_tail_cs_p)],[(#2(multiplicative_exp_tail_cs_p),DummyT)],DummyT)
)
end)
 in ( LrTable.NT 85, ( result, multiplicative_exp_tail_cs1left, 
multiplicative_exp_tail_cs_p1right), rest671)
end
|  ( 131, ( ( _, ( MlyValue.unary_exp_cs unary_exp_cs1, _, 
unary_exp_cs1right)) :: ( _, ( MlyValue.mult_op mult_op1, mult_op1left
, _)) :: rest671)) => let val  result = 
MlyValue.multiplicative_exp_tail_cs (fn _ => let val  (mult_op as 
mult_op1) = mult_op1 ()
 val  (unary_exp_cs as unary_exp_cs1) = unary_exp_cs1 ()
 in (mult_op, unary_exp_cs)
end)
 in ( LrTable.NT 86, ( result, mult_op1left, unary_exp_cs1right), 
rest671)
end
|  ( 132, ( ( _, ( MlyValue.STAR STAR1, STAR1left, STAR1right)) :: 
rest671)) => let val  result = MlyValue.mult_op (fn _ => let val  (
STAR as STAR1) = STAR1 ()
 in (STAR)
end)
 in ( LrTable.NT 89, ( result, STAR1left, STAR1right), rest671)
end
|  ( 133, ( ( _, ( MlyValue.SLASH SLASH1, SLASH1left, SLASH1right)) ::
 rest671)) => let val  result = MlyValue.mult_op (fn _ => let val  (
SLASH as SLASH1) = SLASH1 ()
 in (SLASH)
end)
 in ( LrTable.NT 89, ( result, SLASH1left, SLASH1right), rest671)
end
|  ( 134, ( ( _, ( MlyValue.postfix_exp_cs postfix_exp_cs1, _, 
postfix_exp_cs1right)) :: ( _, ( MlyValue.unary_op unary_op1, 
unary_op1left, _)) :: rest671)) => let val  result = 
MlyValue.unary_exp_cs (fn _ => let val  (unary_op as unary_op1) = 
unary_op1 ()
 val  (postfix_exp_cs as postfix_exp_cs1) = postfix_exp_cs1 ()
 in (
OperationCall (postfix_exp_cs,DummyT,[OclLibPackage,"DummyT",unary_op],[],DummyT)
)
end)
 in ( LrTable.NT 88, ( result, unary_op1left, postfix_exp_cs1right), 
rest671)
end
|  ( 135, ( ( _, ( MlyValue.postfix_exp_cs postfix_exp_cs1, 
postfix_exp_cs1left, postfix_exp_cs1right)) :: rest671)) => let val  
result = MlyValue.unary_exp_cs (fn _ => let val  (postfix_exp_cs as 
postfix_exp_cs1) = postfix_exp_cs1 ()
 in (postfix_exp_cs)
end)
 in ( LrTable.NT 88, ( result, postfix_exp_cs1left, 
postfix_exp_cs1right), rest671)
end
|  ( 136, ( ( _, ( MlyValue.MINUS MINUS1, MINUS1left, MINUS1right)) ::
 rest671)) => let val  result = MlyValue.unary_op (fn _ => let val  (
MINUS as MINUS1) = MINUS1 ()
 in (MINUS)
end)
 in ( LrTable.NT 90, ( result, MINUS1left, MINUS1right), rest671)
end
|  ( 137, ( ( _, ( MlyValue.NOT NOT1, NOT1left, NOT1right)) :: rest671
)) => let val  result = MlyValue.unary_op (fn _ => let val  (NOT as 
NOT1) = NOT1 ()
 in (NOT)
end)
 in ( LrTable.NT 90, ( result, NOT1left, NOT1right), rest671)
end
|  ( 138, ( ( _, ( MlyValue.primary_exp_cs primary_exp_cs1, 
primary_exp_cs1left, primary_exp_cs1right)) :: rest671)) => let val  
result = MlyValue.postfix_exp_cs (fn _ => let val  (primary_exp_cs as 
primary_exp_cs1) = primary_exp_cs1 ()
 in (primary_exp_cs)
end)
 in ( LrTable.NT 91, ( result, primary_exp_cs1left, 
primary_exp_cs1right), rest671)
end
|  ( 139, ( ( _, ( MlyValue.postfix_exp_tail_cs_p 
postfix_exp_tail_cs_p1, _, postfix_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.primary_exp_cs primary_exp_cs1, primary_exp_cs1left, _)) :: 
rest671)) => let val  result = MlyValue.postfix_exp_cs (fn _ => let
 val  (primary_exp_cs as primary_exp_cs1) = primary_exp_cs1 ()
 val  (postfix_exp_tail_cs_p as postfix_exp_tail_cs_p1) = 
postfix_exp_tail_cs_p1 ()
 in (
Logger.debug3 ("literal_call_exp_cs..." ^ "\n");nest_source ([primary_exp_cs]@postfix_exp_tail_cs_p)
)
end)
 in ( LrTable.NT 91, ( result, primary_exp_cs1left, 
postfix_exp_tail_cs_p1right), rest671)
end
|  ( 140, ( ( _, ( MlyValue.literal_exp_cs literal_exp_cs1, 
literal_exp_cs1left, literal_exp_cs1right)) :: rest671)) => let val  
result = MlyValue.primary_exp_cs (fn _ => let val  (literal_exp_cs as 
literal_exp_cs1) = literal_exp_cs1 ()
 in (Logger.debug3 ("literal_call_exp_cs..." ^ "\n");literal_exp_cs)

end)
 in ( LrTable.NT 94, ( result, literal_exp_cs1left, 
literal_exp_cs1right), rest671)
end
|  ( 141, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
 :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)) :: 
rest671)) => let val  result = MlyValue.primary_exp_cs (fn _ => let
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (expression as expression1) = expression1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (expression)
end)
 in ( LrTable.NT 94, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 142, ( ( _, ( MlyValue.property_call_exp_cs property_call_exp_cs1
, property_call_exp_cs1left, property_call_exp_cs1right)) :: rest671))
 => let val  result = MlyValue.primary_exp_cs (fn _ => let val  (
property_call_exp_cs as property_call_exp_cs1) = property_call_exp_cs1
 ()
 in (
Logger.debug3 ("property_call_exp_cs..." ^ "\n");property_call_exp_cs)

end)
 in ( LrTable.NT 94, ( result, property_call_exp_cs1left, 
property_call_exp_cs1right), rest671)
end
|  ( 143, ( ( _, ( MlyValue.if_exp_cs if_exp_cs1, if_exp_cs1left, 
if_exp_cs1right)) :: rest671)) => let val  result = 
MlyValue.primary_exp_cs (fn _ => let val  (if_exp_cs as if_exp_cs1) = 
if_exp_cs1 ()
 in (if_exp_cs)
end)
 in ( LrTable.NT 94, ( result, if_exp_cs1left, if_exp_cs1right), 
rest671)
end
|  ( 144, ( ( _, ( MlyValue.ENDIF ENDIF1, _, ENDIF1right)) :: ( _, ( 
MlyValue.ocl_expression_cs ocl_expression_cs2, _, _)) :: ( _, ( 
MlyValue.ELSE ELSE1, _, _)) :: ( _, ( MlyValue.ocl_expression_cs 
ocl_expression_cs1, _, _)) :: ( _, ( MlyValue.THEN THEN1, _, _)) :: (
 _, ( MlyValue.logical_exp_cs logical_exp_cs1, _, _)) :: ( _, ( 
MlyValue.IF IF1, IF1left, _)) :: rest671)) => let val  result = 
MlyValue.if_exp_cs (fn _ => let val  IF1 = IF1 ()
 val  (logical_exp_cs as logical_exp_cs1) = logical_exp_cs1 ()
 val  THEN1 = THEN1 ()
 val  ocl_expression_cs1 = ocl_expression_cs1 ()
 val  ELSE1 = ELSE1 ()
 val  ocl_expression_cs2 = ocl_expression_cs2 ()
 val  ENDIF1 = ENDIF1 ()
 in (
If (logical_exp_cs,DummyT,ocl_expression_cs1,DummyT,ocl_expression_cs2,DummyT,DummyT)
)
end)
 in ( LrTable.NT 51, ( result, IF1left, ENDIF1right), rest671)
end
|  ( 145, ( ( _, ( MlyValue.postfix_exp_tail_cs postfix_exp_tail_cs1, 
postfix_exp_tail_cs1left, postfix_exp_tail_cs1right)) :: rest671)) =>
 let val  result = MlyValue.postfix_exp_tail_cs_p (fn _ => let val  (
postfix_exp_tail_cs as postfix_exp_tail_cs1) = postfix_exp_tail_cs1 ()
 in (
Logger.debug3 ("end of recursion..." ^ Ocl2String.ocl2string false postfix_exp_tail_cs ^ "\n");[postfix_exp_tail_cs]
)
end)
 in ( LrTable.NT 92, ( result, postfix_exp_tail_cs1left, 
postfix_exp_tail_cs1right), rest671)
end
|  ( 146, ( ( _, ( MlyValue.postfix_exp_tail_cs_p 
postfix_exp_tail_cs_p1, _, postfix_exp_tail_cs_p1right)) :: ( _, ( 
MlyValue.postfix_exp_tail_cs postfix_exp_tail_cs1, 
postfix_exp_tail_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.postfix_exp_tail_cs_p (fn _ => let val  (postfix_exp_tail_cs
 as postfix_exp_tail_cs1) = postfix_exp_tail_cs1 ()
 val  (postfix_exp_tail_cs_p as postfix_exp_tail_cs_p1) = 
postfix_exp_tail_cs_p1 ()
 in (
Logger.debug3 ("add_source ..." ^ "\n" ^  "done");([postfix_exp_tail_cs]@postfix_exp_tail_cs_p)
)
end)
 in ( LrTable.NT 92, ( result, postfix_exp_tail_cs1left, 
postfix_exp_tail_cs_p1right), rest671)
end
|  ( 147, ( ( _, ( MlyValue.property_call_exp_cs property_call_exp_cs1
, _, property_call_exp_cs1right)) :: ( _, ( MlyValue.DOT DOT1, 
DOT1left, _)) :: rest671)) => let val  result = 
MlyValue.postfix_exp_tail_cs (fn _ => let val  DOT1 = DOT1 ()
 val  (property_call_exp_cs as property_call_exp_cs1) = 
property_call_exp_cs1 ()
 in (property_call_exp_cs)
end)
 in ( LrTable.NT 93, ( result, DOT1left, property_call_exp_cs1right), 
rest671)
end
|  ( 148, ( ( _, ( MlyValue.arrow_property_call_exp_cs 
arrow_property_call_exp_cs1, _, arrow_property_call_exp_cs1right)) :: 
( _, ( MlyValue.ARROW_RIGHT ARROW_RIGHT1, ARROW_RIGHT1left, _)) :: 
rest671)) => let val  result = MlyValue.postfix_exp_tail_cs (fn _ =>
 let val  ARROW_RIGHT1 = ARROW_RIGHT1 ()
 val  (arrow_property_call_exp_cs as arrow_property_call_exp_cs1) = 
arrow_property_call_exp_cs1 ()
 in (arrow_property_call_exp_cs)
end)
 in ( LrTable.NT 93, ( result, ARROW_RIGHT1left, 
arrow_property_call_exp_cs1right), rest671)
end
|  ( 149, ( ( _, ( MlyValue.path_name_cs path_name_cs1, 
path_name_cs1left, path_name_cs1right)) :: rest671)) => let val  
result = MlyValue.property_call_exp_cs (fn _ => let val  (path_name_cs
 as path_name_cs1) = path_name_cs1 ()
 in (
AttributeCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs, DummyT)
)
end)
 in ( LrTable.NT 95, ( result, path_name_cs1left, path_name_cs1right),
 rest671)
end
|  ( 150, ( ( _, ( MlyValue.time_exp_cs time_exp_cs1, _, 
time_exp_cs1right)) :: ( _, ( MlyValue.path_name_cs path_name_cs1, 
path_name_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.property_call_exp_cs (fn _ => let val  (path_name_cs as 
path_name_cs1) = path_name_cs1 ()
 val  time_exp_cs1 = time_exp_cs1 ()
 in (
AttributeCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs@["atPre"],DummyT)
)
end)
 in ( LrTable.NT 95, ( result, path_name_cs1left, time_exp_cs1right), 
rest671)
end
|  ( 151, ( ( _, ( MlyValue.property_call_parameters_cs 
property_call_parameters_cs1, _, property_call_parameters_cs1right))
 :: ( _, ( MlyValue.path_name_cs path_name_cs1, path_name_cs1left, _))
 :: rest671)) => let val  result = MlyValue.property_call_exp_cs (fn _
 => let val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  (property_call_parameters_cs as property_call_parameters_cs1) = 
property_call_parameters_cs1 ()
 in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs , property_call_parameters_cs,DummyT)
)
end)
 in ( LrTable.NT 95, ( result, path_name_cs1left, 
property_call_parameters_cs1right), rest671)
end
|  ( 152, ( ( _, ( MlyValue.property_call_parameters_cs 
property_call_parameters_cs1, _, property_call_parameters_cs1right))
 :: ( _, ( MlyValue.time_exp_cs time_exp_cs1, _, _)) :: ( _, ( 
MlyValue.path_name_cs path_name_cs1, path_name_cs1left, _)) :: rest671
)) => let val  result = MlyValue.property_call_exp_cs (fn _ => let
 val  (path_name_cs as path_name_cs1) = path_name_cs1 ()
 val  time_exp_cs1 = time_exp_cs1 ()
 val  (property_call_parameters_cs as property_call_parameters_cs1) = 
property_call_parameters_cs1 ()
 in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,path_name_cs@["atPre"],property_call_parameters_cs,DummyT)
)
end)
 in ( LrTable.NT 95, ( result, path_name_cs1left, 
property_call_parameters_cs1right), rest671)
end
|  ( 153, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
 :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.iterator_name_cs iterator_name_cs1, iterator_name_cs1left, _)
) :: rest671)) => let val  result = 
MlyValue.arrow_property_call_exp_cs (fn _ => let val  (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (expression as expression1) = expression1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Iterator (iterator_name_cs,[],Variable("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
 in ( LrTable.NT 96, ( result, iterator_name_cs1left, 
PAREN_CLOSE1right), rest671)
end
|  ( 154, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
 :: ( _, ( MlyValue.iterator_vars_cs iterator_vars_cs1, _, _)) :: ( _,
 ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.iterator_name_cs iterator_name_cs1, iterator_name_cs1left, _)
) :: rest671)) => let val  result = 
MlyValue.arrow_property_call_exp_cs (fn _ => let val  (
iterator_name_cs as iterator_name_cs1) = iterator_name_cs1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (iterator_vars_cs as iterator_vars_cs1) = iterator_vars_cs1 ()
 val  (expression as expression1) = expression1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Logger.debug3 ("arrow_property_call_cs: iterator with vars..." ^ "\n");Iterator (iterator_name_cs,iterator_vars_cs,Variable("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
 in ( LrTable.NT 96, ( result, iterator_name_cs1left, 
PAREN_CLOSE1right), rest671)
end
|  ( 155, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _))
 :: ( _, ( MlyValue.simple_name simple_name1, simple_name1left, _)) ::
 rest671)) => let val  result = MlyValue.arrow_property_call_exp_cs
 (fn _ => let val  (simple_name as simple_name1) = simple_name1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Logger.debug3 ("arrow_property_call_exp_cs..." ^ "\n");OperationCall (Variable ("dummy_source",DummyT),DummyT,(["arrow"]@[simple_name]),[],DummyT)
)
end)
 in ( LrTable.NT 96, ( result, simple_name1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 156, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.actual_parameter_list_cs 
actual_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN 
PAREN_OPEN1, _, _)) :: ( _, ( MlyValue.simple_name simple_name1, 
simple_name1left, _)) :: rest671)) => let val  result = 
MlyValue.arrow_property_call_exp_cs (fn _ => let val  (simple_name as 
simple_name1) = simple_name1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (actual_parameter_list_cs as actual_parameter_list_cs1) = 
actual_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
OperationCall (Variable ("dummy_source",DummyT),DummyT,(["arrow"]@[simple_name]),actual_parameter_list_cs,DummyT)
)
end)
 in ( LrTable.NT 96, ( result, simple_name1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 157, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.expression expression1, _, _))
 :: ( _, ( MlyValue.VERTICAL_BAR VERTICAL_BAR1, _, _)) :: ( _, ( 
MlyValue.initialized_variable_cs initialized_variable_cs1, _, _)) :: (
 _, ( MlyValue.iterate_vars_cs iterate_vars_cs1, _, _)) :: ( _, ( 
MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( MlyValue.ITERATE 
ITERATE1, ITERATE1left, _)) :: rest671)) => let val  result = 
MlyValue.arrow_property_call_exp_cs (fn _ => let val  ITERATE1 = 
ITERATE1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (iterate_vars_cs as iterate_vars_cs1) = iterate_vars_cs1 ()
 val  (initialized_variable_cs as initialized_variable_cs1) = 
initialized_variable_cs1 ()
 val  VERTICAL_BAR1 = VERTICAL_BAR1 ()
 val  (expression as expression1) = expression1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (
Iterate (iterate_vars_cs,(#1 (initialized_variable_cs)),(#2 (initialized_variable_cs)),(#3 (initialized_variable_cs)),Variable ("dummy_source",DummyT),DummyT,expression,DummyT,DummyT)
)
end)
 in ( LrTable.NT 96, ( result, ITERATE1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 158, ( ( _, ( MlyValue.SEMI_COLON SEMI_COLON1, _, 
SEMI_COLON1right)) :: ( _, ( MlyValue.formal_parameter_list_cs 
formal_parameter_list_cs1, formal_parameter_list_cs1left, _)) :: 
rest671)) => let val  result = MlyValue.iterate_vars_cs (fn _ => let
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  SEMI_COLON1 = SEMI_COLON1 ()
 in (formal_parameter_list_cs)
end)
 in ( LrTable.NT 101, ( result, formal_parameter_list_cs1left, 
SEMI_COLON1right), rest671)
end
|  ( 159, ( ( _, ( MlyValue.VERTICAL_BAR VERTICAL_BAR1, _, 
VERTICAL_BAR1right)) :: ( _, ( MlyValue.formal_parameter_list_cs 
formal_parameter_list_cs1, formal_parameter_list_cs1left, _)) :: 
rest671)) => let val  result = MlyValue.iterator_vars_cs (fn _ => let
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  VERTICAL_BAR1 = VERTICAL_BAR1 ()
 in (formal_parameter_list_cs)
end)
 in ( LrTable.NT 108, ( result, formal_parameter_list_cs1left, 
VERTICAL_BAR1right), rest671)
end
|  ( 160, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.type_specifier type_specifier1,
 _, _)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, PAREN_OPEN1left, _)
) :: rest671)) => let val  result = MlyValue.ntVOID (fn _ => ( let
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (type_specifier as type_specifier1) = type_specifier1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (type_specifier)
end; ()))
 in ( LrTable.NT 116, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 161, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.actual_parameter_list_cs 
actual_parameter_list_cs1, _, _)) :: ( _, ( MlyValue.PAREN_OPEN 
PAREN_OPEN1, PAREN_OPEN1left, _)) :: rest671)) => let val  result = 
MlyValue.property_call_parameters_cs (fn _ => let val  PAREN_OPEN1 = 
PAREN_OPEN1 ()
 val  (actual_parameter_list_cs as actual_parameter_list_cs1) = 
actual_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in (actual_parameter_list_cs)
end)
 in ( LrTable.NT 99, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 162, ( ( _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, 
PAREN_CLOSE1right)) :: ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, 
PAREN_OPEN1left, _)) :: rest671)) => let val  result = 
MlyValue.property_call_parameters_cs (fn _ => let val  PAREN_OPEN1 = 
PAREN_OPEN1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 in ([])
end)
 in ( LrTable.NT 99, ( result, PAREN_OPEN1left, PAREN_CLOSE1right), 
rest671)
end
|  ( 163, ( ( _, ( MlyValue.actual_parameter_list_element_cs 
actual_parameter_list_element_cs1, 
actual_parameter_list_element_cs1left, 
actual_parameter_list_element_cs1right)) :: rest671)) => let val  
result = MlyValue.actual_parameter_list_cs (fn _ => let val  (
actual_parameter_list_element_cs as actual_parameter_list_element_cs1)
 = actual_parameter_list_element_cs1 ()
 in ([actual_parameter_list_element_cs])
end)
 in ( LrTable.NT 103, ( result, actual_parameter_list_element_cs1left,
 actual_parameter_list_element_cs1right), rest671)
end
|  ( 164, ( ( _, ( MlyValue.actual_parameter_list_tail_cs_p 
actual_parameter_list_tail_cs_p1, _, 
actual_parameter_list_tail_cs_p1right)) :: ( _, ( 
MlyValue.actual_parameter_list_element_cs 
actual_parameter_list_element_cs1, 
actual_parameter_list_element_cs1left, _)) :: rest671)) => let val  
result = MlyValue.actual_parameter_list_cs (fn _ => let val  (
actual_parameter_list_element_cs as actual_parameter_list_element_cs1)
 = actual_parameter_list_element_cs1 ()
 val  (actual_parameter_list_tail_cs_p as 
actual_parameter_list_tail_cs_p1) = actual_parameter_list_tail_cs_p1
 ()
 in (
[actual_parameter_list_element_cs]@actual_parameter_list_tail_cs_p)

end)
 in ( LrTable.NT 103, ( result, actual_parameter_list_element_cs1left,
 actual_parameter_list_tail_cs_p1right), rest671)
end
|  ( 165, ( ( _, ( MlyValue.actual_parameter_list_tail_cs 
actual_parameter_list_tail_cs1, actual_parameter_list_tail_cs1left, 
actual_parameter_list_tail_cs1right)) :: rest671)) => let val  result
 = MlyValue.actual_parameter_list_tail_cs_p (fn _ => let val  (
actual_parameter_list_tail_cs as actual_parameter_list_tail_cs1) = 
actual_parameter_list_tail_cs1 ()
 in (actual_parameter_list_tail_cs)
end)
 in ( LrTable.NT 105, ( result, actual_parameter_list_tail_cs1left, 
actual_parameter_list_tail_cs1right), rest671)
end
|  ( 166, ( ( _, ( MlyValue.actual_parameter_list_tail_cs_p 
actual_parameter_list_tail_cs_p1, _, 
actual_parameter_list_tail_cs_p1right)) :: ( _, ( 
MlyValue.actual_parameter_list_tail_cs actual_parameter_list_tail_cs1,
 actual_parameter_list_tail_cs1left, _)) :: rest671)) => let val  
result = MlyValue.actual_parameter_list_tail_cs_p (fn _ => let val  (
actual_parameter_list_tail_cs as actual_parameter_list_tail_cs1) = 
actual_parameter_list_tail_cs1 ()
 val  (actual_parameter_list_tail_cs_p as 
actual_parameter_list_tail_cs_p1) = actual_parameter_list_tail_cs_p1
 ()
 in (actual_parameter_list_tail_cs@actual_parameter_list_tail_cs_p)

end)
 in ( LrTable.NT 105, ( result, actual_parameter_list_tail_cs1left, 
actual_parameter_list_tail_cs_p1right), rest671)
end
|  ( 167, ( ( _, ( MlyValue.actual_parameter_list_cs 
actual_parameter_list_cs1, _, actual_parameter_list_cs1right)) :: ( _,
 ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val  
result = MlyValue.actual_parameter_list_tail_cs (fn _ => let val  
COMMA1 = COMMA1 ()
 val  (actual_parameter_list_cs as actual_parameter_list_cs1) = 
actual_parameter_list_cs1 ()
 in (actual_parameter_list_cs)
end)
 in ( LrTable.NT 104, ( result, COMMA1left, 
actual_parameter_list_cs1right), rest671)
end
|  ( 168, ( ( _, ( MlyValue.expression expression1, expression1left, 
expression1right)) :: rest671)) => let val  result = 
MlyValue.actual_parameter_list_element_cs (fn _ => let val  (
expression as expression1) = expression1 ()
 in (expression,DummyT)
end)
 in ( LrTable.NT 106, ( result, expression1left, expression1right), 
rest671)
end
|  ( 169, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
 let val  result = MlyValue.actual_parameter_list_element_cs (fn _ =>
 let val  (formal_parameter_cs as formal_parameter_cs1) = 
formal_parameter_cs1 ()
 in (
Variable (#1(formal_parameter_cs),#2(formal_parameter_cs)),#2(formal_parameter_cs)
)
end)
 in ( LrTable.NT 106, ( result, formal_parameter_cs1left, 
formal_parameter_cs1right), rest671)
end
|  ( 170, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
 let val  result = MlyValue.formal_parameter_list_cs (fn _ => let val 
 (formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1
 ()
 in ([formal_parameter_cs])
end)
 in ( LrTable.NT 38, ( result, formal_parameter_cs1left, 
formal_parameter_cs1right), rest671)
end
|  ( 171, ( ( _, ( MlyValue.formal_parameter_list_tail_cs 
formal_parameter_list_tail_cs1, _, formal_parameter_list_tail_cs1right
)) :: ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.formal_parameter_list_cs (fn _ => let val  (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
 val  (formal_parameter_list_tail_cs as formal_parameter_list_tail_cs1
) = formal_parameter_list_tail_cs1 ()
 in ([formal_parameter_cs]@formal_parameter_list_tail_cs)
end)
 in ( LrTable.NT 38, ( result, formal_parameter_cs1left, 
formal_parameter_list_tail_cs1right), rest671)
end
|  ( 172, ( ( _, ( MlyValue.formal_parameter_list_cs 
formal_parameter_list_cs1, _, formal_parameter_list_cs1right)) :: ( _,
 ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val  
result = MlyValue.formal_parameter_list_tail_cs (fn _ => let val  
COMMA1 = COMMA1 ()
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 in (formal_parameter_list_cs)
end)
 in ( LrTable.NT 39, ( result, COMMA1left, 
formal_parameter_list_cs1right), rest671)
end
|  ( 173, ( ( _, ( MlyValue.formal_parameter_type_specifier 
formal_parameter_type_specifier1, _, 
formal_parameter_type_specifier1right)) :: ( _, ( MlyValue.simple_name
 simple_name1, simple_name1left, _)) :: rest671)) => let val  result =
 MlyValue.formal_parameter_cs (fn _ => let val  (simple_name as 
simple_name1) = simple_name1 ()
 val  (formal_parameter_type_specifier as 
formal_parameter_type_specifier1) = formal_parameter_type_specifier1
 ()
 in (simple_name,formal_parameter_type_specifier)
end)
 in ( LrTable.NT 37, ( result, simple_name1left, 
formal_parameter_type_specifier1right), rest671)
end
|  ( 174, ( ( _, ( MlyValue.type_specifier type_specifier1, _, 
type_specifier1right)) :: ( _, ( MlyValue.COLON COLON1, COLON1left, _)
) :: rest671)) => let val  result = 
MlyValue.formal_parameter_type_specifier (fn _ => let val  COLON1 = 
COLON1 ()
 val  (type_specifier as type_specifier1) = type_specifier1 ()
 in (type_specifier)
end)
 in ( LrTable.NT 107, ( result, COLON1left, type_specifier1right), 
rest671)
end
|  ( 175, ( ( _, ( MlyValue.simple_type_specifier_cs 
simple_type_specifier_cs1, simple_type_specifier_cs1left, 
simple_type_specifier_cs1right)) :: rest671)) => let val  result = 
MlyValue.type_specifier (fn _ => let val  (simple_type_specifier_cs
 as simple_type_specifier_cs1) = simple_type_specifier_cs1 ()
 in (
Logger.debug3 ("type_specifier ..." ^ "\n");simple_type_specifier_cs)

end)
 in ( LrTable.NT 19, ( result, simple_type_specifier_cs1left, 
simple_type_specifier_cs1right), rest671)
end
|  ( 176, ( ( _, ( MlyValue.collection_type_specifier_cs 
collection_type_specifier_cs1, collection_type_specifier_cs1left, 
collection_type_specifier_cs1right)) :: rest671)) => let val  result =
 MlyValue.type_specifier (fn _ => let val  (
collection_type_specifier_cs as collection_type_specifier_cs1) = 
collection_type_specifier_cs1 ()
 in (collection_type_specifier_cs)
end)
 in ( LrTable.NT 19, ( result, collection_type_specifier_cs1left, 
collection_type_specifier_cs1right), rest671)
end
|  ( 177, ( ( _, ( MlyValue.simple_name simple_name1, simple_name1left
, simple_name1right)) :: rest671)) => let val  result = 
MlyValue.simple_type_specifier_cs (fn _ => let val  (simple_name as 
simple_name1) = simple_name1 ()
 in (
Logger.debug3 ("simple_type_name_specifier_cs : " ^ simple_name ^ "\n");string_to_type simple_name
)
end)
 in ( LrTable.NT 52, ( result, simple_name1left, simple_name1right), 
rest671)
end
|  ( 178, ( ( _, ( MlyValue.initialized_variable_cs 
initialized_variable_cs1, initialized_variable_cs1left, 
initialized_variable_cs1right)) :: rest671)) => let val  result = 
MlyValue.initialized_variable_list_cs (fn _ => let val  (
initialized_variable_cs as initialized_variable_cs1) = 
initialized_variable_cs1 ()
 in ([initialized_variable_cs])
end)
 in ( LrTable.NT 73, ( result, initialized_variable_cs1left, 
initialized_variable_cs1right), rest671)
end
|  ( 179, ( ( _, ( MlyValue.initialized_variable_list_tail_cs_p 
initialized_variable_list_tail_cs_p1, 
initialized_variable_list_tail_cs_p1left, 
initialized_variable_list_tail_cs_p1right)) :: rest671)) => let val  
result = MlyValue.initialized_variable_list_cs (fn _ => let val  (
initialized_variable_list_tail_cs_p as 
initialized_variable_list_tail_cs_p1) = 
initialized_variable_list_tail_cs_p1 ()
 in (initialized_variable_list_tail_cs_p)
end)
 in ( LrTable.NT 73, ( result, 
initialized_variable_list_tail_cs_p1left, 
initialized_variable_list_tail_cs_p1right), rest671)
end
|  ( 180, ( ( _, ( MlyValue.initialized_variable_list_tail_cs 
initialized_variable_list_tail_cs1, 
initialized_variable_list_tail_cs1left, 
initialized_variable_list_tail_cs1right)) :: rest671)) => let val  
result = MlyValue.initialized_variable_list_tail_cs_p (fn _ => let
 val  (initialized_variable_list_tail_cs as 
initialized_variable_list_tail_cs1) = 
initialized_variable_list_tail_cs1 ()
 in ([initialized_variable_list_tail_cs])
end)
 in ( LrTable.NT 109, ( result, initialized_variable_list_tail_cs1left
, initialized_variable_list_tail_cs1right), rest671)
end
|  ( 181, ( ( _, ( MlyValue.initialized_variable_list_tail_cs_p 
initialized_variable_list_tail_cs_p1, _, 
initialized_variable_list_tail_cs_p1right)) :: ( _, ( 
MlyValue.initialized_variable_list_tail_cs 
initialized_variable_list_tail_cs1, 
initialized_variable_list_tail_cs1left, _)) :: rest671)) => let val  
result = MlyValue.initialized_variable_list_tail_cs_p (fn _ => let
 val  (initialized_variable_list_tail_cs as 
initialized_variable_list_tail_cs1) = 
initialized_variable_list_tail_cs1 ()
 val  (initialized_variable_list_tail_cs_p as 
initialized_variable_list_tail_cs_p1) = 
initialized_variable_list_tail_cs_p1 ()
 in (
[initialized_variable_list_tail_cs]@(initialized_variable_list_tail_cs_p)
)
end)
 in ( LrTable.NT 109, ( result, initialized_variable_list_tail_cs1left
, initialized_variable_list_tail_cs_p1right), rest671)
end
|  ( 182, ( ( _, ( MlyValue.initialized_variable_cs 
initialized_variable_cs1, _, initialized_variable_cs1right)) :: ( _, (
 MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let val  
result = MlyValue.initialized_variable_list_tail_cs (fn _ => let val  
COMMA1 = COMMA1 ()
 val  (initialized_variable_cs as initialized_variable_cs1) = 
initialized_variable_cs1 ()
 in (initialized_variable_cs)
end)
 in ( LrTable.NT 110, ( result, COMMA1left, 
initialized_variable_cs1right), rest671)
end
|  ( 183, ( ( _, ( MlyValue.variable_initializer variable_initializer1
, _, variable_initializer1right)) :: ( _, ( 
MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.initialized_variable_cs (fn _ => let val  (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
 val  (variable_initializer as variable_initializer1) = 
variable_initializer1 ()
 in (
(#1 formal_parameter_cs),(#2 formal_parameter_cs),variable_initializer
)
end)
 in ( LrTable.NT 102, ( result, formal_parameter_cs1left, 
variable_initializer1right), rest671)
end
|  ( 184, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
 let val  result = MlyValue.variable_declaration_cs (fn _ => let val 
 (formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1
 ()
 in (formal_parameter_cs)
end)
 in ( LrTable.NT 112, ( result, formal_parameter_cs1left, 
formal_parameter_cs1right), rest671)
end
|  ( 185, ( ( _, ( MlyValue.ocl_expression_cs ocl_expression_cs1, _, 
ocl_expression_cs1right)) :: ( _, ( MlyValue.EQUALS EQUALS1, 
EQUALS1left, _)) :: rest671)) => let val  result = 
MlyValue.variable_initializer (fn _ => let val  EQUALS1 = EQUALS1 ()
 val  (ocl_expression_cs as ocl_expression_cs1) = ocl_expression_cs1
 ()
 in (ocl_expression_cs)
end)
 in ( LrTable.NT 111, ( result, EQUALS1left, ocl_expression_cs1right),
 rest671)
end
|  ( 186, ( ( _, ( MlyValue.variable_declaration_cs 
variable_declaration_cs1, variable_declaration_cs1left, 
variable_declaration_cs1right)) :: rest671)) => let val  result = 
MlyValue.variable_declaration_list_cs (fn _ => let val  (
variable_declaration_cs as variable_declaration_cs1) = 
variable_declaration_cs1 ()
 in ([variable_declaration_cs])
end)
 in ( LrTable.NT 113, ( result, variable_declaration_cs1left, 
variable_declaration_cs1right), rest671)
end
|  ( 187, ( ( _, ( MlyValue.variable_declaration_list_tail_cs 
variable_declaration_list_tail_cs1, _, 
variable_declaration_list_tail_cs1right)) :: ( _, ( 
MlyValue.variable_declaration_cs variable_declaration_cs1, 
variable_declaration_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.variable_declaration_list_cs (fn _ => let val  (
variable_declaration_cs as variable_declaration_cs1) = 
variable_declaration_cs1 ()
 val  (variable_declaration_list_tail_cs as 
variable_declaration_list_tail_cs1) = 
variable_declaration_list_tail_cs1 ()
 in ([variable_declaration_cs]@variable_declaration_list_tail_cs)
end)
 in ( LrTable.NT 113, ( result, variable_declaration_cs1left, 
variable_declaration_list_tail_cs1right), rest671)
end
|  ( 188, ( ( _, ( MlyValue.variable_declaration_list_cs 
variable_declaration_list_cs1, _, variable_declaration_list_cs1right))
 :: ( _, ( MlyValue.COMMA COMMA1, COMMA1left, _)) :: rest671)) => let
 val  result = MlyValue.variable_declaration_list_tail_cs (fn _ => let
 val  COMMA1 = COMMA1 ()
 val  (variable_declaration_list_cs as variable_declaration_list_cs1)
 = variable_declaration_list_cs1 ()
 in (variable_declaration_list_cs)
end)
 in ( LrTable.NT 114, ( result, COMMA1left, 
variable_declaration_list_cs1right), rest671)
end
|  ( 189, ( ( _, ( MlyValue.END END1, _, END1right)) :: ( _, ( 
MlyValue.model_def_cs model_def_cs1, _, _)) :: ( _, ( MlyValue.MODEL 
MODEL1, MODEL1left, _)) :: rest671)) => let val  result = 
MlyValue.model_spec_cs (fn _ => let val  MODEL1 = MODEL1 ()
 val  (model_def_cs as model_def_cs1) = model_def_cs1 ()
 val  END1 = END1 ()
 in (model_def_cs)
end)
 in ( LrTable.NT 118, ( result, MODEL1left, END1right), rest671)
end
|  ( 190, ( ( _, ( MlyValue.model_class_def_tail_cs_p 
model_class_def_tail_cs_p1, _, model_class_def_tail_cs_p1right)) :: (
 _, ( MlyValue.simple_name simple_name1, simple_name1left, _)) :: 
rest671)) => let val  result = MlyValue.model_def_cs (fn _ => let val 
 (simple_name as simple_name1) = simple_name1 ()
 val  (model_class_def_tail_cs_p as model_class_def_tail_cs_p1) = 
model_class_def_tail_cs_p1 ()
 in (
List.map (fn (a,b) => rename_classifier ([simple_name]@a) b) model_class_def_tail_cs_p
)
end)
 in ( LrTable.NT 119, ( result, simple_name1left, 
model_class_def_tail_cs_p1right), rest671)
end
|  ( 191, ( ( _, ( MlyValue.model_class_def_cs model_class_def_cs1, 
model_class_def_cs1left, model_class_def_cs1right)) :: rest671)) =>
 let val  result = MlyValue.model_class_def_tail_cs_p (fn _ => let
 val  (model_class_def_cs as model_class_def_cs1) = 
model_class_def_cs1 ()
 in ([model_class_def_cs])
end)
 in ( LrTable.NT 120, ( result, model_class_def_cs1left, 
model_class_def_cs1right), rest671)
end
|  ( 192, ( ( _, ( MlyValue.model_class_def_tail_cs_p 
model_class_def_tail_cs_p1, _, model_class_def_tail_cs_p1right)) :: (
 _, ( MlyValue.model_class_def_cs model_class_def_cs1, 
model_class_def_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.model_class_def_tail_cs_p (fn _ => let val  (
model_class_def_cs as model_class_def_cs1) = model_class_def_cs1 ()
 val  (model_class_def_tail_cs_p as model_class_def_tail_cs_p1) = 
model_class_def_tail_cs_p1 ()
 in ([model_class_def_cs]@(model_class_def_tail_cs_p))
end)
 in ( LrTable.NT 120, ( result, model_class_def_cs1left, 
model_class_def_tail_cs_p1right), rest671)
end
|  ( 193, ( ( _, ( MlyValue.model_component_def_cs 
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, ( 
MlyValue.simple_name simple_name1, _, _)) :: ( _, ( MlyValue.CLASS 
CLASS1, CLASS1left, _)) :: rest671)) => let val  result = 
MlyValue.model_class_def_cs (fn _ => let val  CLASS1 = CLASS1 ()
 val  (simple_name as simple_name1) = simple_name1 ()
 val  (model_component_def_cs as model_component_def_cs1) = 
model_component_def_cs1 ()
 in ([simple_name],merge_classifiers (model_component_def_cs))
end)
 in ( LrTable.NT 121, ( result, CLASS1left, 
model_component_def_cs1right), rest671)
end
|  ( 194, ( ( _, ( MlyValue.model_ops_spec_cs model_ops_spec_cs1, 
model_ops_spec_cs1left, model_ops_spec_cs1right)) :: rest671)) => let
 val  result = MlyValue.model_component_def_cs (fn _ => let val  (
model_ops_spec_cs as model_ops_spec_cs1) = model_ops_spec_cs1 ()
 in ([model_ops_spec_cs])
end)
 in ( LrTable.NT 122, ( result, model_ops_spec_cs1left, 
model_ops_spec_cs1right), rest671)
end
|  ( 195, ( ( _, ( MlyValue.model_component_def_cs 
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, ( 
MlyValue.model_ops_spec_cs model_ops_spec_cs1, model_ops_spec_cs1left,
 _)) :: rest671)) => let val  result = MlyValue.model_component_def_cs
 (fn _ => let val  (model_ops_spec_cs as model_ops_spec_cs1) = 
model_ops_spec_cs1 ()
 val  (model_component_def_cs as model_component_def_cs1) = 
model_component_def_cs1 ()
 in ([model_ops_spec_cs]@(model_component_def_cs))
end)
 in ( LrTable.NT 122, ( result, model_ops_spec_cs1left, 
model_component_def_cs1right), rest671)
end
|  ( 196, ( ( _, ( MlyValue.model_atts_spec_cs model_atts_spec_cs1, 
model_atts_spec_cs1left, model_atts_spec_cs1right)) :: rest671)) =>
 let val  result = MlyValue.model_component_def_cs (fn _ => let val  (
model_atts_spec_cs as model_atts_spec_cs1) = model_atts_spec_cs1 ()
 in ([model_atts_spec_cs])
end)
 in ( LrTable.NT 122, ( result, model_atts_spec_cs1left, 
model_atts_spec_cs1right), rest671)
end
|  ( 197, ( ( _, ( MlyValue.model_component_def_cs 
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, ( 
MlyValue.model_atts_spec_cs model_atts_spec_cs1, 
model_atts_spec_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.model_component_def_cs (fn _ => let val  (model_atts_spec_cs
 as model_atts_spec_cs1) = model_atts_spec_cs1 ()
 val  (model_component_def_cs as model_component_def_cs1) = 
model_component_def_cs1 ()
 in ([model_atts_spec_cs]@(model_component_def_cs))
end)
 in ( LrTable.NT 122, ( result, model_atts_spec_cs1left, 
model_component_def_cs1right), rest671)
end
|  ( 198, ( ( _, ( MlyValue.model_cons_spec_cs model_cons_spec_cs1, 
model_cons_spec_cs1left, model_cons_spec_cs1right)) :: rest671)) =>
 let val  result = MlyValue.model_component_def_cs (fn _ => let val  (
model_cons_spec_cs as model_cons_spec_cs1) = model_cons_spec_cs1 ()
 in ([model_cons_spec_cs])
end)
 in ( LrTable.NT 122, ( result, model_cons_spec_cs1left, 
model_cons_spec_cs1right), rest671)
end
|  ( 199, ( ( _, ( MlyValue.model_component_def_cs 
model_component_def_cs1, _, model_component_def_cs1right)) :: ( _, ( 
MlyValue.model_cons_spec_cs model_cons_spec_cs1, 
model_cons_spec_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.model_component_def_cs (fn _ => let val  (model_cons_spec_cs
 as model_cons_spec_cs1) = model_cons_spec_cs1 ()
 val  (model_component_def_cs as model_component_def_cs1) = 
model_component_def_cs1 ()
 in ([model_cons_spec_cs]@(model_component_def_cs))
end)
 in ( LrTable.NT 122, ( result, model_cons_spec_cs1left, 
model_component_def_cs1right), rest671)
end
|  ( 200, ( ( _, ( MlyValue.model_op_def_tail_cs_p 
model_op_def_tail_cs_p1, _, model_op_def_tail_cs_p1right)) :: ( _, ( 
MlyValue.OPERATIONS OPERATIONS1, OPERATIONS1left, _)) :: rest671)) =>
 let val  result = MlyValue.model_ops_spec_cs (fn _ => let val  
OPERATIONS1 = OPERATIONS1 ()
 val  (model_op_def_tail_cs_p as model_op_def_tail_cs_p1) = 
model_op_def_tail_cs_p1 ()
 in (operations_to_classifier model_op_def_tail_cs_p)
end)
 in ( LrTable.NT 123, ( result, OPERATIONS1left, 
model_op_def_tail_cs_p1right), rest671)
end
|  ( 201, ( ( _, ( MlyValue.model_op_def_cs model_op_def_cs1, 
model_op_def_cs1left, model_op_def_cs1right)) :: rest671)) => let val 
 result = MlyValue.model_op_def_tail_cs_p (fn _ => let val  (
model_op_def_cs as model_op_def_cs1) = model_op_def_cs1 ()
 in ([model_op_def_cs])
end)
 in ( LrTable.NT 125, ( result, model_op_def_cs1left, 
model_op_def_cs1right), rest671)
end
|  ( 202, ( ( _, ( MlyValue.model_op_def_tail_cs_p 
model_op_def_tail_cs_p1, _, model_op_def_tail_cs_p1right)) :: ( _, ( 
MlyValue.model_op_def_cs model_op_def_cs1, model_op_def_cs1left, _))
 :: rest671)) => let val  result = MlyValue.model_op_def_tail_cs_p (fn
 _ => let val  (model_op_def_cs as model_op_def_cs1) = 
model_op_def_cs1 ()
 val  (model_op_def_tail_cs_p as model_op_def_tail_cs_p1) = 
model_op_def_tail_cs_p1 ()
 in ([model_op_def_cs]@(model_op_def_tail_cs_p))
end)
 in ( LrTable.NT 125, ( result, model_op_def_cs1left, 
model_op_def_tail_cs_p1right), rest671)
end
|  ( 203, ( ( _, ( MlyValue.operation_constraint_cs_p 
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
 _, ( MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, ( 
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
 ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
 => let val  result = MlyValue.model_op_def_cs (fn _ => let val  (
simple_name as simple_name1) = simple_name1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 val  (operation_constraint_cs_p as operation_constraint_cs_p1) = 
operation_constraint_cs_p1 ()
 in (
{name=simple_name,
			   precondition=(dispatch_pre_or_post pre operation_constraint_cs_p),
			   postcondition=(dispatch_pre_or_post post operation_constraint_cs_p),
			   body=[],arguments=formal_parameter_list_cs,
			   result=OclVoid,
			   isQuery=false,
			   scope=ClassifierScope:Rep_Core.Scope,
			   stereotypes=[],
			   visibility=public:Rep_Core.Visibility}:operation
)
end)
 in ( LrTable.NT 124, ( result, simple_name1left, 
operation_constraint_cs_p1right), rest671)
end
|  ( 204, ( ( _, ( MlyValue.operation_constraint_cs_p 
operation_constraint_cs_p1, _, operation_constraint_cs_p1right)) :: (
 _, ( MlyValue.operation_return_type_specifier_cs 
operation_return_type_specifier_cs1, _, _)) :: ( _, ( 
MlyValue.PAREN_CLOSE PAREN_CLOSE1, _, _)) :: ( _, ( 
MlyValue.formal_parameter_list_cs formal_parameter_list_cs1, _, _)) ::
 ( _, ( MlyValue.PAREN_OPEN PAREN_OPEN1, _, _)) :: ( _, ( 
MlyValue.simple_name simple_name1, simple_name1left, _)) :: rest671))
 => let val  result = MlyValue.model_op_def_cs (fn _ => let val  (
simple_name as simple_name1) = simple_name1 ()
 val  PAREN_OPEN1 = PAREN_OPEN1 ()
 val  (formal_parameter_list_cs as formal_parameter_list_cs1) = 
formal_parameter_list_cs1 ()
 val  PAREN_CLOSE1 = PAREN_CLOSE1 ()
 val  (operation_return_type_specifier_cs as 
operation_return_type_specifier_cs1) = 
operation_return_type_specifier_cs1 ()
 val  (operation_constraint_cs_p as operation_constraint_cs_p1) = 
operation_constraint_cs_p1 ()
 in (
{name=simple_name,
			   precondition=(dispatch_pre_or_post pre operation_constraint_cs_p),
                           postcondition=(dispatch_pre_or_post post operation_constraint_cs_p),
                           body=[],
                           arguments=formal_parameter_list_cs,
                           result=operation_return_type_specifier_cs,
                           isQuery=false,
                           scope=ClassifierScope:Rep_Core.Scope,
                           stereotypes=[],
                           visibility=public:Rep_Core.Visibility}:operation
)
end)
 in ( LrTable.NT 124, ( result, simple_name1left, 
operation_constraint_cs_p1right), rest671)
end
|  ( 205, ( ( _, ( MlyValue.model_att_value_def_tail_cs_p 
model_att_value_def_tail_cs_p1, _, model_att_value_def_tail_cs_p1right
)) :: ( _, ( MlyValue.ATTRIBUTES ATTRIBUTES1, ATTRIBUTES1left, _)) :: 
rest671)) => let val  result = MlyValue.model_atts_spec_cs (fn _ =>
 let val  ATTRIBUTES1 = ATTRIBUTES1 ()
 val  (model_att_value_def_tail_cs_p as model_att_value_def_tail_cs_p1
) = model_att_value_def_tail_cs_p1 ()
 in (attributes_to_classifier model_att_value_def_tail_cs_p)
end)
 in ( LrTable.NT 126, ( result, ATTRIBUTES1left, 
model_att_value_def_tail_cs_p1right), rest671)
end
|  ( 206, ( ( _, ( MlyValue.model_att_value_def_cs 
model_att_value_def_cs1, model_att_value_def_cs1left, 
model_att_value_def_cs1right)) :: rest671)) => let val  result = 
MlyValue.model_att_value_def_tail_cs_p (fn _ => let val  (
model_att_value_def_cs as model_att_value_def_cs1) = 
model_att_value_def_cs1 ()
 in ([model_att_value_def_cs])
end)
 in ( LrTable.NT 128, ( result, model_att_value_def_cs1left, 
model_att_value_def_cs1right), rest671)
end
|  ( 207, ( ( _, ( MlyValue.model_att_value_def_tail_cs_p 
model_att_value_def_tail_cs_p1, _, model_att_value_def_tail_cs_p1right
)) :: ( _, ( MlyValue.model_att_value_def_cs model_att_value_def_cs1, 
model_att_value_def_cs1left, _)) :: rest671)) => let val  result = 
MlyValue.model_att_value_def_tail_cs_p (fn _ => let val  (
model_att_value_def_cs as model_att_value_def_cs1) = 
model_att_value_def_cs1 ()
 val  (model_att_value_def_tail_cs_p as model_att_value_def_tail_cs_p1
) = model_att_value_def_tail_cs_p1 ()
 in ([model_att_value_def_cs]@(model_att_value_def_tail_cs_p))
end)
 in ( LrTable.NT 128, ( result, model_att_value_def_cs1left, 
model_att_value_def_tail_cs_p1right), rest671)
end
|  ( 208, ( ( _, ( MlyValue.formal_parameter_cs formal_parameter_cs1, 
formal_parameter_cs1left, formal_parameter_cs1right)) :: rest671)) =>
 let val  result = MlyValue.model_att_value_def_cs (fn _ => let val  (
formal_parameter_cs as formal_parameter_cs1) = formal_parameter_cs1 ()
 in (
{name=(#1 formal_parameter_cs),attr_type=(#2 formal_parameter_cs),visibility=public,scope=ClassifierScope,stereotypes=[],init=NONE}
)
end)
 in ( LrTable.NT 127, ( result, formal_parameter_cs1left, 
formal_parameter_cs1right), rest671)
end
|  ( 209, ( ( _, ( MlyValue.model_cons_def_tail_cs_p 
model_cons_def_tail_cs_p1, _, model_cons_def_tail_cs_p1right)) :: ( _,
 ( MlyValue.CONSTRAINTS CONSTRAINTS1, CONSTRAINTS1left, _)) :: rest671
)) => let val  result = MlyValue.model_cons_spec_cs (fn _ => let val  
CONSTRAINTS1 = CONSTRAINTS1 ()
 val  (model_cons_def_tail_cs_p as model_cons_def_tail_cs_p1) = 
model_cons_def_tail_cs_p1 ()
 in (constraints_to_classifier model_cons_def_tail_cs_p)
end)
 in ( LrTable.NT 129, ( result, CONSTRAINTS1left, 
model_cons_def_tail_cs_p1right), rest671)
end
|  ( 210, ( ( _, ( MlyValue.classifier_constraint_cs_p 
classifier_constraint_cs_p1, classifier_constraint_cs_p1left, 
classifier_constraint_cs_p1right)) :: rest671)) => let val  result = 
MlyValue.model_cons_def_tail_cs_p (fn _ => let val  (
classifier_constraint_cs_p as classifier_constraint_cs_p1) = 
classifier_constraint_cs_p1 ()
 in (classifier_constraint_cs_p)
end)
 in ( LrTable.NT 130, ( result, classifier_constraint_cs_p1left, 
classifier_constraint_cs_p1right), rest671)
end
| _ => raise (mlyAction i392)
end
val void = MlyValue.VOID
val extract = fn a => (fn MlyValue.START x => x
| _ => let exception ParseInternal
	in raise ParseInternal end) a ()
end
end
structure Tokens : OclParser_TOKENS =
struct
type svalue = ParserData.svalue
type ('a,'b) token = ('a,'b) Token.token
fun EOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 0,(
ParserData.MlyValue.VOID,p1,p2))
fun TICK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
ParserData.MlyValue.TICK (fn () => i),p1,p2))
fun COMMA (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
ParserData.MlyValue.COMMA (fn () => i),p1,p2))
fun ARROW_RIGHT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
ParserData.MlyValue.ARROW_RIGHT (fn () => i),p1,p2))
fun DOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
ParserData.MlyValue.DOT (fn () => i),p1,p2))
fun DBL_DOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
ParserData.MlyValue.DBL_DOT (fn () => i),p1,p2))
fun COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
ParserData.MlyValue.COLON (fn () => i),p1,p2))
fun DBL_COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
ParserData.MlyValue.DBL_COLON (fn () => i),p1,p2))
fun SEMI_COLON (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
ParserData.MlyValue.SEMI_COLON (fn () => i),p1,p2))
fun EQUALS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
ParserData.MlyValue.EQUALS (fn () => i),p1,p2))
fun QUESTION_MARK (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
ParserData.MlyValue.QUESTION_MARK (fn () => i),p1,p2))
fun HASH (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 11,(
ParserData.MlyValue.HASH (fn () => i),p1,p2))
fun AT_PRE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 12,(
ParserData.MlyValue.AT_PRE (fn () => i),p1,p2))
fun BAG (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
ParserData.MlyValue.BAG (fn () => i),p1,p2))
fun COLLECTION (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
ParserData.MlyValue.COLLECTION (fn () => i),p1,p2))
fun SEQUENCE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
ParserData.MlyValue.SEQUENCE (fn () => i),p1,p2))
fun ORDERED_SET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
ParserData.MlyValue.ORDERED_SET (fn () => i),p1,p2))
fun SET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 17,(
ParserData.MlyValue.SET (fn () => i),p1,p2))
fun TUPLE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 18,(
ParserData.MlyValue.TUPLE (fn () => i),p1,p2))
fun TUPLE_TYPE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 19,(
ParserData.MlyValue.TUPLE_TYPE (fn () => i),p1,p2))
fun BRACKET_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 20,(
ParserData.MlyValue.BRACKET_OPEN (fn () => i),p1,p2))
fun BRACKET_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 21,(
ParserData.MlyValue.BRACKET_CLOSE (fn () => i),p1,p2))
fun CARAT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 22,(
ParserData.MlyValue.CARAT (fn () => i),p1,p2))
fun DBL_CARAT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 23,(
ParserData.MlyValue.DBL_CARAT (fn () => i),p1,p2))
fun BODY (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 24,(
ParserData.MlyValue.BODY (fn () => i),p1,p2))
fun CONTEXT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 25,(
ParserData.MlyValue.CONTEXT (fn () => i),p1,p2))
fun DEF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 26,(
ParserData.MlyValue.DEF (fn () => i),p1,p2))
fun DERIVE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 27,(
ParserData.MlyValue.DERIVE (fn () => i),p1,p2))
fun ELSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 28,(
ParserData.MlyValue.ELSE (fn () => i),p1,p2))
fun ENDIF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 29,(
ParserData.MlyValue.ENDIF (fn () => i),p1,p2))
fun ENDPACKAGE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 30,(
ParserData.MlyValue.ENDPACKAGE (fn () => i),p1,p2))
fun FALSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 31,(
ParserData.MlyValue.FALSE (fn () => i),p1,p2))
fun NULL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 32,(
ParserData.MlyValue.NULL (fn () => i),p1,p2))
fun FORALL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 33,(
ParserData.MlyValue.FORALL (fn () => i),p1,p2))
fun TRUE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 34,(
ParserData.MlyValue.TRUE (fn () => i),p1,p2))
fun IF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 35,(
ParserData.MlyValue.IF (fn () => i),p1,p2))
fun IN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 36,(
ParserData.MlyValue.IN (fn () => i),p1,p2))
fun INIT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 37,(
ParserData.MlyValue.INIT (fn () => i),p1,p2))
fun INV (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 38,(
ParserData.MlyValue.INV (fn () => i),p1,p2))
fun LET (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 39,(
ParserData.MlyValue.LET (fn () => i),p1,p2))
fun PACKAGE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 40,(
ParserData.MlyValue.PACKAGE (fn () => i),p1,p2))
fun PRE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 41,(
ParserData.MlyValue.PRE (fn () => i),p1,p2))
fun POST (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 42,(
ParserData.MlyValue.POST (fn () => i),p1,p2))
fun THEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 43,(
ParserData.MlyValue.THEN (fn () => i),p1,p2))
fun PAREN_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 44,(
ParserData.MlyValue.PAREN_OPEN (fn () => i),p1,p2))
fun PAREN_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 45,(
ParserData.MlyValue.PAREN_CLOSE (fn () => i),p1,p2))
fun BRACE_OPEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 46,(
ParserData.MlyValue.BRACE_OPEN (fn () => i),p1,p2))
fun BRACE_CLOSE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 47,(
ParserData.MlyValue.BRACE_CLOSE (fn () => i),p1,p2))
fun VERTICAL_BAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 48,(
ParserData.MlyValue.VERTICAL_BAR (fn () => i),p1,p2))
fun GUARD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 49,(
ParserData.MlyValue.GUARD (fn () => i),p1,p2))
fun ITERATE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 50,(
ParserData.MlyValue.ITERATE (fn () => i),p1,p2))
fun SELECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 51,(
ParserData.MlyValue.SELECT (fn () => i),p1,p2))
fun REJECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 52,(
ParserData.MlyValue.REJECT (fn () => i),p1,p2))
fun COLLECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 53,(
ParserData.MlyValue.COLLECT (fn () => i),p1,p2))
fun ANY (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 54,(
ParserData.MlyValue.ANY (fn () => i),p1,p2))
fun EXISTS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 55,(
ParserData.MlyValue.EXISTS (fn () => i),p1,p2))
fun ONE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 56,(
ParserData.MlyValue.ONE (fn () => i),p1,p2))
fun ISUNIQUE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 57,(
ParserData.MlyValue.ISUNIQUE (fn () => i),p1,p2))
fun OCLISTYPEOF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 58,(
ParserData.MlyValue.OCLISTYPEOF (fn () => i),p1,p2))
fun OCLISKINDOF (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 59,(
ParserData.MlyValue.OCLISKINDOF (fn () => i),p1,p2))
fun OCLASTYPE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 60,(
ParserData.MlyValue.OCLASTYPE (fn () => i),p1,p2))
fun MINUS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 61,(
ParserData.MlyValue.MINUS (fn () => i),p1,p2))
fun STAR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 62,(
ParserData.MlyValue.STAR (fn () => i),p1,p2))
fun SLASH (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 63,(
ParserData.MlyValue.SLASH (fn () => i),p1,p2))
fun PLUS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 64,(
ParserData.MlyValue.PLUS (fn () => i),p1,p2))
fun REL_NOTEQUAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 65,(
ParserData.MlyValue.REL_NOTEQUAL (fn () => i),p1,p2))
fun REL_GT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 66,(
ParserData.MlyValue.REL_GT (fn () => i),p1,p2))
fun REL_LT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 67,(
ParserData.MlyValue.REL_LT (fn () => i),p1,p2))
fun REL_GTE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 68,(
ParserData.MlyValue.REL_GTE (fn () => i),p1,p2))
fun REL_LTE (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 69,(
ParserData.MlyValue.REL_LTE (fn () => i),p1,p2))
fun LOG_AND (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 70,(
ParserData.MlyValue.LOG_AND (fn () => i),p1,p2))
fun LOG_OR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 71,(
ParserData.MlyValue.LOG_OR (fn () => i),p1,p2))
fun LOG_XOR (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 72,(
ParserData.MlyValue.LOG_XOR (fn () => i),p1,p2))
fun LOG_IMPL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 73,(
ParserData.MlyValue.LOG_IMPL (fn () => i),p1,p2))
fun NOT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 74,(
ParserData.MlyValue.NOT (fn () => i),p1,p2))
fun INTEGER_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 75,(
ParserData.MlyValue.INTEGER_LITERAL (fn () => i),p1,p2))
fun REAL_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 76,(
ParserData.MlyValue.REAL_LITERAL (fn () => i),p1,p2))
fun STRING_LITERAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 77,(
ParserData.MlyValue.STRING_LITERAL (fn () => i),p1,p2))
fun SIMPLE_NAME (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 78,(
ParserData.MlyValue.SIMPLE_NAME (fn () => i),p1,p2))
fun MODEL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 79,(
ParserData.MlyValue.MODEL (fn () => i),p1,p2))
fun OPERATIONS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 80,(
ParserData.MlyValue.OPERATIONS (fn () => i),p1,p2))
fun ATTRIBUTES (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 81,(
ParserData.MlyValue.ATTRIBUTES (fn () => i),p1,p2))
fun ASSOCIATIONS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 82,(
ParserData.MlyValue.ASSOCIATIONS (fn () => i),p1,p2))
fun BETWEEN (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 83,(
ParserData.MlyValue.BETWEEN (fn () => i),p1,p2))
fun END (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 84,(
ParserData.MlyValue.END (fn () => i),p1,p2))
fun CONSTRAINTS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 85,(
ParserData.MlyValue.CONSTRAINTS (fn () => i),p1,p2))
fun CLASS (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 86,(
ParserData.MlyValue.CLASS (fn () => i),p1,p2))
end
end
