1.1 --- a/src/HOL/TPTP/ROOT.ML Thu Mar 08 22:04:40 2012 +0100
1.2 +++ b/src/HOL/TPTP/ROOT.ML Fri Mar 09 15:38:55 2012 +0000
1.3 @@ -7,7 +7,8 @@
1.4 *)
1.5
1.6 use_thys [
1.7 - "ATP_Theory_Export"
1.8 + "ATP_Theory_Export",
1.9 + "TPTP_Parser"
1.10 ];
1.11
1.12 Unsynchronized.setmp Proofterm.proofs (!Proofterm.proofs)
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
2.2 +++ b/src/HOL/TPTP/TPTP_Parser.thy Fri Mar 09 15:38:55 2012 +0000
2.3 @@ -0,0 +1,51 @@
2.4 +(* Title: HOL/TPTP/TPTP_Parser.thy
2.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
2.6 +
2.7 +Importing TPTP files into Isabelle/HOL:
2.8 +* parsing TPTP formulas;
2.9 +* interpreting TPTP formulas as HOL terms (i.e. importing types, and
2.10 + type-checking the terms);
2.11 +*)
2.12 +
2.13 +theory TPTP_Parser
2.14 +imports Main
2.15 +uses
2.16 + "TPTP_Parser/ml_yacc_lib.ML" (*generated from ML-Yacc's lib*)
2.17 +
2.18 + "TPTP_Parser/tptp_syntax.ML"
2.19 + "TPTP_Parser/tptp_lexyacc.ML" (*generated from tptp.lex and tptp.yacc*)
2.20 + "TPTP_Parser/tptp_parser.ML"
2.21 + "TPTP_Parser/tptp_problem_name.ML"
2.22 + "TPTP_Parser/tptp_interpret.ML"
2.23 +
2.24 +begin
2.25 +
2.26 +text {*The TPTP parser was generated using ML-Yacc, and needs the
2.27 +ML-Yacc library to operate. This library is included with the parser,
2.28 +and we include the next section in accordance with ML-Yacc's terms of
2.29 +use.*}
2.30 +
2.31 +section "ML-YACC COPYRIGHT NOTICE, LICENSE AND DISCLAIMER."
2.32 +text {*
2.33 +Copyright 1989, 1990 by David R. Tarditi Jr. and Andrew W. Appel
2.34 +
2.35 +Permission to use, copy, modify, and distribute this software and its
2.36 +documentation for any purpose and without fee is hereby granted,
2.37 +provided that the above copyright notice appear in all copies and that
2.38 +both the copyright notice and this permission notice and warranty
2.39 +disclaimer appear in supporting documentation, and that the names of
2.40 +David R. Tarditi Jr. and Andrew W. Appel not be used in advertising or
2.41 +publicity pertaining to distribution of the software without specific,
2.42 +written prior permission.
2.43 +
2.44 +David R. Tarditi Jr. and Andrew W. Appel disclaim all warranties with
2.45 +regard to this software, including all implied warranties of
2.46 +merchantability and fitness. In no event shall David R. Tarditi
2.47 +Jr. and Andrew W. Appel be liable for any special, indirect or
2.48 +consequential damages or any damages whatsoever resulting from loss of
2.49 +use, data or profits, whether in an action of contract, negligence or
2.50 +other tortious action, arising out of or in connection with the use or
2.51 +performance of this software.
2.52 +*}
2.53 +
2.54 +end
2.55 \ No newline at end of file
3.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
3.2 +++ b/src/HOL/TPTP/TPTP_Parser/README Fri Mar 09 15:38:55 2012 +0000
3.3 @@ -0,0 +1,33 @@
3.4 +The TPTP parser is generated using ML-Yacc and relies on the ML-Yacc
3.5 +library to function. The ML-Yacc library is an external piece of
3.6 +software that needs a small modification for use in Isabelle. The
3.7 +file "make_tptp_parser" patches the ML-Yacc library, generates the
3.8 +TPTP parser, and patches that to conform to Isabelle's naming
3.9 +conventions.
3.10 +
3.11 +In order to generate the parser from its lex/yacc definition you need
3.12 +to have the ML-Yacc binaries. The sources can be downloaded via SVN as
3.13 +follows:
3.14 +
3.15 + svn co --username anonsvn \
3.16 + https://smlnj-gforge.cs.uchicago.edu/svn/smlnj/ml-yacc/trunk ml-yacc
3.17 +
3.18 +ML-Yacc is usually distributed with Standard ML of New Jersey, and its
3.19 +binaries can also be obtained as packages for some distributions of
3.20 +Linux.
3.21 +
3.22 +The generated parser needs ML-Yacc's library. This is distributed with
3.23 +ML-Yacc's source code, in the lib/ directory.
3.24 +
3.25 +Assuming that you've got the ml-lex and ml-yacc binaries, and have a
3.26 +copy of the ML-Yacc sources in this directory, then running
3.27 +"make_tptp_parser" will generate two files:
3.28 +
3.29 + ml_yacc_lib.ML -- this is a compilation of slightly modified files
3.30 + making up ML-Yacc's library.
3.31 +
3.32 + tptp_lexyacc.ML -- this is a compilation of the SML files making up
3.33 + the TPTP parser.
3.34 +
3.35 +Nik Sultana
3.36 +8th March 2012
3.37 \ No newline at end of file
4.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
4.2 +++ b/src/HOL/TPTP/TPTP_Parser/make_tptp_parser Fri Mar 09 15:38:55 2012 +0000
4.3 @@ -0,0 +1,84 @@
4.4 +#!/bin/bash
4.5 +#
4.6 +# make_tptp_parser - Generates Isabelle-friendly version of ML-Yacc's library,
4.7 +# runs ML-Yacc to generate TPTP parser, and makes the
4.8 +# generated parser Isabelle-friendly.
4.9 +#
4.10 +# This code is based on that used in src/Tools/Metis to adapt Metis for
4.11 +# use in Isabelle.
4.12 +
4.13 +MLYACCDIR=./ml-yacc
4.14 +INTERMEDIATE_FILES="tptp.yacc.sig tptp.lex.sml tptp.yacc.sml"
4.15 +MLYACCLIB_FILES="base.sig join.sml lrtable.sml stream.sml parser2.sml"
4.16 +
4.17 +echo "Cleaning"
4.18 +rm -f {tptp_lexyacc,ml_yacc_lib}.ML
4.19 +echo "Generating lexer and parser"
4.20 +ml-lex tptp.lex && ml-yacc tptp.yacc
4.21 +echo "Generating tptp_lexyacc.ML"
4.22 +(
4.23 + cat <<EOF
4.24 +
4.25 +(******************************************************************)
4.26 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.27 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.28 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.29 +(******************************************************************)
4.30 +
4.31 +(*
4.32 + This file is produced from the parser generated by ML-Yacc from the
4.33 + source files tptp.lex and tptp.yacc.
4.34 +*)
4.35 +EOF
4.36 +
4.37 +for FILE in $INTERMEDIATE_FILES
4.38 +do
4.39 + perl -p -e 's/\bref\b/Unsynchronized.ref/g;' -e 's/Unsafe\.(.*)/\1/g;' $FILE
4.40 +done
4.41 +) > tptp_lexyacc.ML
4.42 +
4.43 +rm -f $INTERMEDIATE_FILES tptp.yacc.desc
4.44 +
4.45 +#Now patch and collate ML-Yacc's library files
4.46 +echo "Generating ml_yacc_lib.ML"
4.47 +(
4.48 + cat <<EOF
4.49 +
4.50 +(******************************************************************)
4.51 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.52 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.53 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
4.54 +(******************************************************************)
4.55 +
4.56 +print_depth 0;
4.57 +
4.58 +(*
4.59 + This file is generated from the contents of ML-Yacc's lib directory.
4.60 + ML-Yacc's COPYRIGHT-file contents follow:
4.61 +
4.62 +EOF
4.63 + perl -pe 'print " ";' ml-yacc/COPYRIGHT
4.64 + echo "*)"
4.65 +
4.66 +for FILE in $MLYACCLIB_FILES
4.67 +do
4.68 + echo
4.69 + echo "(**** Original file: $FILE ****)"
4.70 + echo
4.71 + echo -e " $FILE" >&2
4.72 + perl -p -e 's/\bref\b/Unsynchronized.ref/g;' \
4.73 + -e 's/Unsafe\.(.*)/\1/g;' \
4.74 + -e 's/\bconcat\b/String.concat/g;' \
4.75 + -e 's/(?<!List\.)foldr\b/List.foldr/g;' \
4.76 + -e 's/\bfoldl\b/List.foldl/g;' \
4.77 + -e 's/val print = fn s => TextIO\.output\(TextIO\.stdOut,s\)$//g;' \
4.78 + -e 's/\bprint\b/TextIO.print/g;' \
4.79 + $MLYACCDIR/lib/$FILE
4.80 + done
4.81 +
4.82 + cat <<EOF
4.83 +;
4.84 +print_depth 10;
4.85 +EOF
4.86 +
4.87 +) > ml_yacc_lib.ML
4.88 \ No newline at end of file
5.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
5.2 +++ b/src/HOL/TPTP/TPTP_Parser/ml_yacc_lib.ML Fri Mar 09 15:38:55 2012 +0000
5.3 @@ -0,0 +1,1064 @@
5.4 +
5.5 +(******************************************************************)
5.6 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
5.7 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
5.8 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
5.9 +(******************************************************************)
5.10 +
5.11 +print_depth 0;
5.12 +
5.13 +(*
5.14 + This file is generated from the contents of ML-Yacc's lib directory.
5.15 + ML-Yacc's COPYRIGHT-file contents follow:
5.16 +
5.17 + ML-YACC COPYRIGHT NOTICE, LICENSE AND DISCLAIMER.
5.18 +
5.19 + Copyright 1989, 1990 by David R. Tarditi Jr. and Andrew W. Appel
5.20 +
5.21 + Permission to use, copy, modify, and distribute this software and its
5.22 + documentation for any purpose and without fee is hereby granted,
5.23 + provided that the above copyright notice appear in all copies and that
5.24 + both the copyright notice and this permission notice and warranty
5.25 + disclaimer appear in supporting documentation, and that the names of
5.26 + David R. Tarditi Jr. and Andrew W. Appel not be used in advertising
5.27 + or publicity pertaining to distribution of the software without
5.28 + specific, written prior permission.
5.29 +
5.30 + David R. Tarditi Jr. and Andrew W. Appel disclaim all warranties with regard to
5.31 + this software, including all implied warranties of merchantability and fitness.
5.32 + In no event shall David R. Tarditi Jr. and Andrew W. Appel be liable for any
5.33 + special, indirect or consequential damages or any damages whatsoever resulting
5.34 + from loss of use, data or profits, whether in an action of contract, negligence
5.35 + or other tortious action, arising out of or in connection with the use or
5.36 + performance of this software.
5.37 +*)
5.38 +
5.39 +(**** Original file: base.sig ****)
5.40 +
5.41 +(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
5.42 +
5.43 +(* base.sig: Base signature file for SML-Yacc. This file contains signatures
5.44 + that must be loaded before any of the files produced by ML-Yacc are loaded
5.45 +*)
5.46 +
5.47 +(* STREAM: signature for a lazy stream.*)
5.48 +
5.49 +signature STREAM =
5.50 + sig type 'xa stream
5.51 + val streamify : (unit -> '_a) -> '_a stream
5.52 + val cons : '_a * '_a stream -> '_a stream
5.53 + val get : '_a stream -> '_a * '_a stream
5.54 + end
5.55 +
5.56 +(* LR_TABLE: signature for an LR Table.
5.57 +
5.58 + The list of actions and gotos passed to mkLrTable must be ordered by state
5.59 + number. The values for state 0 are the first in the list, the values for
5.60 + state 1 are next, etc.
5.61 +*)
5.62 +
5.63 +signature LR_TABLE =
5.64 + sig
5.65 + datatype ('a,'b) pairlist = EMPTY | PAIR of 'a * 'b * ('a,'b) pairlist
5.66 + datatype state = STATE of int
5.67 + datatype term = T of int
5.68 + datatype nonterm = NT of int
5.69 + datatype action = SHIFT of state
5.70 + | REDUCE of int
5.71 + | ACCEPT
5.72 + | ERROR
5.73 + type table
5.74 +
5.75 + val numStates : table -> int
5.76 + val numRules : table -> int
5.77 + val describeActions : table -> state ->
5.78 + (term,action) pairlist * action
5.79 + val describeGoto : table -> state -> (nonterm,state) pairlist
5.80 + val action : table -> state * term -> action
5.81 + val goto : table -> state * nonterm -> state
5.82 + val initialState : table -> state
5.83 + exception Goto of state * nonterm
5.84 +
5.85 + val mkLrTable : {actions : ((term,action) pairlist * action) array,
5.86 + gotos : (nonterm,state) pairlist array,
5.87 + numStates : int, numRules : int,
5.88 + initialState : state} -> table
5.89 + end
5.90 +
5.91 +(* TOKEN: signature revealing the internal structure of a token. This signature
5.92 + TOKEN distinct from the signature {parser name}_TOKENS produced by ML-Yacc.
5.93 + The {parser name}_TOKENS structures contain some types and functions to
5.94 + construct tokens from values and positions.
5.95 +
5.96 + The representation of token was very carefully chosen here to allow the
5.97 + polymorphic parser to work without knowing the types of semantic values
5.98 + or line numbers.
5.99 +
5.100 + This has had an impact on the TOKENS structure produced by SML-Yacc, which
5.101 + is a structure parameter to lexer functors. We would like to have some
5.102 + type 'a token which functions to construct tokens would create. A
5.103 + constructor function for a integer token might be
5.104 +
5.105 + INT: int * 'a * 'a -> 'a token.
5.106 +
5.107 + This is not possible because we need to have tokens with the representation
5.108 + given below for the polymorphic parser.
5.109 +
5.110 + Thus our constructur functions for tokens have the form:
5.111 +
5.112 + INT: int * 'a * 'a -> (svalue,'a) token
5.113 +
5.114 + This in turn has had an impact on the signature that lexers for SML-Yacc
5.115 + must match and the types that a user must declare in the user declarations
5.116 + section of lexers.
5.117 +*)
5.118 +
5.119 +signature TOKEN =
5.120 + sig
5.121 + structure LrTable : LR_TABLE
5.122 + datatype ('a,'b) token = TOKEN of LrTable.term * ('a * 'b * 'b)
5.123 + val sameToken : ('a,'b) token * ('a,'b) token -> bool
5.124 + end
5.125 +
5.126 +(* LR_PARSER: signature for a polymorphic LR parser *)
5.127 +
5.128 +signature LR_PARSER =
5.129 + sig
5.130 + structure Stream: STREAM
5.131 + structure LrTable : LR_TABLE
5.132 + structure Token : TOKEN
5.133 +
5.134 + sharing LrTable = Token.LrTable
5.135 +
5.136 + exception ParseError
5.137 +
5.138 + val parse : {table : LrTable.table,
5.139 + lexer : ('_b,'_c) Token.token Stream.stream,
5.140 + arg: 'arg,
5.141 + saction : int *
5.142 + '_c *
5.143 + (LrTable.state * ('_b * '_c * '_c)) list *
5.144 + 'arg ->
5.145 + LrTable.nonterm *
5.146 + ('_b * '_c * '_c) *
5.147 + ((LrTable.state *('_b * '_c * '_c)) list),
5.148 + void : '_b,
5.149 + ec : { is_keyword : LrTable.term -> bool,
5.150 + noShift : LrTable.term -> bool,
5.151 + preferred_change : (LrTable.term list * LrTable.term list) list,
5.152 + errtermvalue : LrTable.term -> '_b,
5.153 + showTerminal : LrTable.term -> string,
5.154 + terms: LrTable.term list,
5.155 + error : string * '_c * '_c -> unit
5.156 + },
5.157 + lookahead : int (* max amount of lookahead used in *)
5.158 + (* error correction *)
5.159 + } -> '_b *
5.160 + (('_b,'_c) Token.token Stream.stream)
5.161 + end
5.162 +
5.163 +(* LEXER: a signature that most lexers produced for use with SML-Yacc's
5.164 + output will match. The user is responsible for declaring type token,
5.165 + type pos, and type svalue in the UserDeclarations section of a lexer.
5.166 +
5.167 + Note that type token is abstract in the lexer. This allows SML-Yacc to
5.168 + create a TOKENS signature for use with lexers produced by ML-Lex that
5.169 + treats the type token abstractly. Lexers that are functors parametrized by
5.170 + a Tokens structure matching a TOKENS signature cannot examine the structure
5.171 + of tokens.
5.172 +*)
5.173 +
5.174 +signature LEXER =
5.175 + sig
5.176 + structure UserDeclarations :
5.177 + sig
5.178 + type ('a,'b) token
5.179 + type pos
5.180 + type svalue
5.181 + end
5.182 + val makeLexer : (int -> string) -> unit ->
5.183 + (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
5.184 + end
5.185 +
5.186 +(* ARG_LEXER: the %arg option of ML-Lex allows users to produce lexers which
5.187 + also take an argument before yielding a function from unit to a token
5.188 +*)
5.189 +
5.190 +signature ARG_LEXER =
5.191 + sig
5.192 + structure UserDeclarations :
5.193 + sig
5.194 + type ('a,'b) token
5.195 + type pos
5.196 + type svalue
5.197 + type arg
5.198 + end
5.199 + val makeLexer : (int -> string) -> UserDeclarations.arg -> unit ->
5.200 + (UserDeclarations.svalue,UserDeclarations.pos) UserDeclarations.token
5.201 + end
5.202 +
5.203 +(* PARSER_DATA: the signature of ParserData structures in {parser name}LrValsFun
5.204 + produced by SML-Yacc. All such structures match this signature.
5.205 +
5.206 + The {parser name}LrValsFun produces a structure which contains all the values
5.207 + except for the lexer needed to call the polymorphic parser mentioned
5.208 + before.
5.209 +
5.210 +*)
5.211 +
5.212 +signature PARSER_DATA =
5.213 + sig
5.214 + (* the type of line numbers *)
5.215 +
5.216 + type pos
5.217 +
5.218 + (* the type of semantic values *)
5.219 +
5.220 + type svalue
5.221 +
5.222 + (* the type of the user-supplied argument to the parser *)
5.223 + type arg
5.224 +
5.225 + (* the intended type of the result of the parser. This value is
5.226 + produced by applying extract from the structure Actions to the
5.227 + final semantic value resultiing from a parse.
5.228 + *)
5.229 +
5.230 + type result
5.231 +
5.232 + structure LrTable : LR_TABLE
5.233 + structure Token : TOKEN
5.234 + sharing Token.LrTable = LrTable
5.235 +
5.236 + (* structure Actions contains the functions which mantain the
5.237 + semantic values stack in the parser. Void is used to provide
5.238 + a default value for the semantic stack.
5.239 + *)
5.240 +
5.241 + structure Actions :
5.242 + sig
5.243 + val actions : int * pos *
5.244 + (LrTable.state * (svalue * pos * pos)) list * arg->
5.245 + LrTable.nonterm * (svalue * pos * pos) *
5.246 + ((LrTable.state *(svalue * pos * pos)) list)
5.247 + val void : svalue
5.248 + val extract : svalue -> result
5.249 + end
5.250 +
5.251 + (* structure EC contains information used to improve error
5.252 + recovery in an error-correcting parser *)
5.253 +
5.254 + structure EC :
5.255 + sig
5.256 + val is_keyword : LrTable.term -> bool
5.257 + val noShift : LrTable.term -> bool
5.258 + val preferred_change : (LrTable.term list * LrTable.term list) list
5.259 + val errtermvalue : LrTable.term -> svalue
5.260 + val showTerminal : LrTable.term -> string
5.261 + val terms: LrTable.term list
5.262 + end
5.263 +
5.264 + (* table is the LR table for the parser *)
5.265 +
5.266 + val table : LrTable.table
5.267 + end
5.268 +
5.269 +(* signature PARSER is the signature that most user parsers created by
5.270 + SML-Yacc will match.
5.271 +*)
5.272 +
5.273 +signature PARSER =
5.274 + sig
5.275 + structure Token : TOKEN
5.276 + structure Stream : STREAM
5.277 + exception ParseError
5.278 +
5.279 + (* type pos is the type of line numbers *)
5.280 +
5.281 + type pos
5.282 +
5.283 + (* type result is the type of the result from the parser *)
5.284 +
5.285 + type result
5.286 +
5.287 + (* the type of the user-supplied argument to the parser *)
5.288 + type arg
5.289 +
5.290 + (* type svalue is the type of semantic values for the semantic value
5.291 + stack
5.292 + *)
5.293 +
5.294 + type svalue
5.295 +
5.296 + (* val makeLexer is used to create a stream of tokens for the parser *)
5.297 +
5.298 + val makeLexer : (int -> string) ->
5.299 + (svalue,pos) Token.token Stream.stream
5.300 +
5.301 + (* val parse takes a stream of tokens and a function to TextIO.print
5.302 + errors and returns a value of type result and a stream containing
5.303 + the unused tokens
5.304 + *)
5.305 +
5.306 + val parse : int * ((svalue,pos) Token.token Stream.stream) *
5.307 + (string * pos * pos -> unit) * arg ->
5.308 + result * (svalue,pos) Token.token Stream.stream
5.309 +
5.310 + val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
5.311 + bool
5.312 + end
5.313 +
5.314 +(* signature ARG_PARSER is the signature that will be matched by parsers whose
5.315 + lexer takes an additional argument.
5.316 +*)
5.317 +
5.318 +signature ARG_PARSER =
5.319 + sig
5.320 + structure Token : TOKEN
5.321 + structure Stream : STREAM
5.322 + exception ParseError
5.323 +
5.324 + type arg
5.325 + type lexarg
5.326 + type pos
5.327 + type result
5.328 + type svalue
5.329 +
5.330 + val makeLexer : (int -> string) -> lexarg ->
5.331 + (svalue,pos) Token.token Stream.stream
5.332 + val parse : int * ((svalue,pos) Token.token Stream.stream) *
5.333 + (string * pos * pos -> unit) * arg ->
5.334 + result * (svalue,pos) Token.token Stream.stream
5.335 +
5.336 + val sameToken : (svalue,pos) Token.token * (svalue,pos) Token.token ->
5.337 + bool
5.338 + end
5.339 +
5.340 +
5.341 +(**** Original file: join.sml ****)
5.342 +
5.343 +(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
5.344 +
5.345 +(* functor Join creates a user parser by putting together a Lexer structure,
5.346 + an LrValues structure, and a polymorphic parser structure. Note that
5.347 + the Lexer and LrValues structure must share the type pos (i.e. the type
5.348 + of line numbers), the type svalues for semantic values, and the type
5.349 + of tokens.
5.350 +*)
5.351 +
5.352 +functor Join(structure Lex : LEXER
5.353 + structure ParserData: PARSER_DATA
5.354 + structure LrParser : LR_PARSER
5.355 + sharing ParserData.LrTable = LrParser.LrTable
5.356 + sharing ParserData.Token = LrParser.Token
5.357 + sharing type Lex.UserDeclarations.svalue = ParserData.svalue
5.358 + sharing type Lex.UserDeclarations.pos = ParserData.pos
5.359 + sharing type Lex.UserDeclarations.token = ParserData.Token.token)
5.360 + : PARSER =
5.361 +struct
5.362 + structure Token = ParserData.Token
5.363 + structure Stream = LrParser.Stream
5.364 +
5.365 + exception ParseError = LrParser.ParseError
5.366 +
5.367 + type arg = ParserData.arg
5.368 + type pos = ParserData.pos
5.369 + type result = ParserData.result
5.370 + type svalue = ParserData.svalue
5.371 + val makeLexer = LrParser.Stream.streamify o Lex.makeLexer
5.372 + val parse = fn (lookahead,lexer,error,arg) =>
5.373 + (fn (a,b) => (ParserData.Actions.extract a,b))
5.374 + (LrParser.parse {table = ParserData.table,
5.375 + lexer=lexer,
5.376 + lookahead=lookahead,
5.377 + saction = ParserData.Actions.actions,
5.378 + arg=arg,
5.379 + void= ParserData.Actions.void,
5.380 + ec = {is_keyword = ParserData.EC.is_keyword,
5.381 + noShift = ParserData.EC.noShift,
5.382 + preferred_change = ParserData.EC.preferred_change,
5.383 + errtermvalue = ParserData.EC.errtermvalue,
5.384 + error=error,
5.385 + showTerminal = ParserData.EC.showTerminal,
5.386 + terms = ParserData.EC.terms}}
5.387 + )
5.388 + val sameToken = Token.sameToken
5.389 +end
5.390 +
5.391 +(* functor JoinWithArg creates a variant of the parser structure produced
5.392 + above. In this case, the makeLexer take an additional argument before
5.393 + yielding a value of type unit -> (svalue,pos) token
5.394 + *)
5.395 +
5.396 +functor JoinWithArg(structure Lex : ARG_LEXER
5.397 + structure ParserData: PARSER_DATA
5.398 + structure LrParser : LR_PARSER
5.399 + sharing ParserData.LrTable = LrParser.LrTable
5.400 + sharing ParserData.Token = LrParser.Token
5.401 + sharing type Lex.UserDeclarations.svalue = ParserData.svalue
5.402 + sharing type Lex.UserDeclarations.pos = ParserData.pos
5.403 + sharing type Lex.UserDeclarations.token = ParserData.Token.token)
5.404 + : ARG_PARSER =
5.405 +struct
5.406 + structure Token = ParserData.Token
5.407 + structure Stream = LrParser.Stream
5.408 +
5.409 + exception ParseError = LrParser.ParseError
5.410 +
5.411 + type arg = ParserData.arg
5.412 + type lexarg = Lex.UserDeclarations.arg
5.413 + type pos = ParserData.pos
5.414 + type result = ParserData.result
5.415 + type svalue = ParserData.svalue
5.416 +
5.417 + val makeLexer = fn s => fn arg =>
5.418 + LrParser.Stream.streamify (Lex.makeLexer s arg)
5.419 + val parse = fn (lookahead,lexer,error,arg) =>
5.420 + (fn (a,b) => (ParserData.Actions.extract a,b))
5.421 + (LrParser.parse {table = ParserData.table,
5.422 + lexer=lexer,
5.423 + lookahead=lookahead,
5.424 + saction = ParserData.Actions.actions,
5.425 + arg=arg,
5.426 + void= ParserData.Actions.void,
5.427 + ec = {is_keyword = ParserData.EC.is_keyword,
5.428 + noShift = ParserData.EC.noShift,
5.429 + preferred_change = ParserData.EC.preferred_change,
5.430 + errtermvalue = ParserData.EC.errtermvalue,
5.431 + error=error,
5.432 + showTerminal = ParserData.EC.showTerminal,
5.433 + terms = ParserData.EC.terms}}
5.434 + )
5.435 + val sameToken = Token.sameToken
5.436 +end;
5.437 +
5.438 +(**** Original file: lrtable.sml ****)
5.439 +
5.440 +(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
5.441 +structure LrTable : LR_TABLE =
5.442 + struct
5.443 + open Array List
5.444 + infix 9 sub
5.445 + datatype ('a,'b) pairlist = EMPTY
5.446 + | PAIR of 'a * 'b * ('a,'b) pairlist
5.447 + datatype term = T of int
5.448 + datatype nonterm = NT of int
5.449 + datatype state = STATE of int
5.450 + datatype action = SHIFT of state
5.451 + | REDUCE of int (* rulenum from grammar *)
5.452 + | ACCEPT
5.453 + | ERROR
5.454 + exception Goto of state * nonterm
5.455 + type table = {states: int, rules : int,initialState: state,
5.456 + action: ((term,action) pairlist * action) array,
5.457 + goto : (nonterm,state) pairlist array}
5.458 + val numStates = fn ({states,...} : table) => states
5.459 + val numRules = fn ({rules,...} : table) => rules
5.460 + val describeActions =
5.461 + fn ({action,...} : table) =>
5.462 + fn (STATE s) => action sub s
5.463 + val describeGoto =
5.464 + fn ({goto,...} : table) =>
5.465 + fn (STATE s) => goto sub s
5.466 + fun findTerm (T term,row,default) =
5.467 + let fun find (PAIR (T key,data,r)) =
5.468 + if key < term then find r
5.469 + else if key=term then data
5.470 + else default
5.471 + | find EMPTY = default
5.472 + in find row
5.473 + end
5.474 + fun findNonterm (NT nt,row) =
5.475 + let fun find (PAIR (NT key,data,r)) =
5.476 + if key < nt then find r
5.477 + else if key=nt then SOME data
5.478 + else NONE
5.479 + | find EMPTY = NONE
5.480 + in find row
5.481 + end
5.482 + val action = fn ({action,...} : table) =>
5.483 + fn (STATE state,term) =>
5.484 + let val (row,default) = action sub state
5.485 + in findTerm(term,row,default)
5.486 + end
5.487 + val goto = fn ({goto,...} : table) =>
5.488 + fn (a as (STATE state,nonterm)) =>
5.489 + case findNonterm(nonterm,goto sub state)
5.490 + of SOME state => state
5.491 + | NONE => raise (Goto a)
5.492 + val initialState = fn ({initialState,...} : table) => initialState
5.493 + val mkLrTable = fn {actions,gotos,initialState,numStates,numRules} =>
5.494 + ({action=actions,goto=gotos,
5.495 + states=numStates,
5.496 + rules=numRules,
5.497 + initialState=initialState} : table)
5.498 +end;
5.499 +
5.500 +(**** Original file: stream.sml ****)
5.501 +
5.502 +(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
5.503 +
5.504 +(* Stream: a structure implementing a lazy stream. The signature STREAM
5.505 + is found in base.sig *)
5.506 +
5.507 +structure Stream :> STREAM =
5.508 +struct
5.509 + datatype 'a str = EVAL of 'a * 'a str Unsynchronized.ref | UNEVAL of (unit->'a)
5.510 +
5.511 + type 'a stream = 'a str Unsynchronized.ref
5.512 +
5.513 + fun get(Unsynchronized.ref(EVAL t)) = t
5.514 + | get(s as Unsynchronized.ref(UNEVAL f)) =
5.515 + let val t = (f(), Unsynchronized.ref(UNEVAL f)) in s := EVAL t; t end
5.516 +
5.517 + fun streamify f = Unsynchronized.ref(UNEVAL f)
5.518 + fun cons(a,s) = Unsynchronized.ref(EVAL(a,s))
5.519 +
5.520 +end;
5.521 +
5.522 +(**** Original file: parser2.sml ****)
5.523 +
5.524 +(* ML-Yacc Parser Generator (c) 1989 Andrew W. Appel, David R. Tarditi *)
5.525 +
5.526 +(* parser.sml: This is a parser driver for LR tables with an error-recovery
5.527 + routine added to it. The routine used is described in detail in this
5.528 + article:
5.529 +
5.530 + 'A Practical Method for LR and LL Syntactic Error Diagnosis and
5.531 + Recovery', by M. Burke and G. Fisher, ACM Transactions on
5.532 + Programming Langauges and Systems, Vol. 9, No. 2, April 1987,
5.533 + pp. 164-197.
5.534 +
5.535 + This program is an implementation is the partial, deferred method discussed
5.536 + in the article. The algorithm and data structures used in the program
5.537 + are described below.
5.538 +
5.539 + This program assumes that all semantic actions are delayed. A semantic
5.540 + action should produce a function from unit -> value instead of producing the
5.541 + normal value. The parser returns the semantic value on the top of the
5.542 + stack when accept is encountered. The user can deconstruct this value
5.543 + and apply the unit -> value function in it to get the answer.
5.544 +
5.545 + It also assumes that the lexer is a lazy stream.
5.546 +
5.547 + Data Structures:
5.548 + ----------------
5.549 +
5.550 + * The parser:
5.551 +
5.552 + The state stack has the type
5.553 +
5.554 + (state * (semantic value * line # * line #)) list
5.555 +
5.556 + The parser keeps a queue of (state stack * lexer pair). A lexer pair
5.557 + consists of a terminal * value pair and a lexer. This allows the
5.558 + parser to reconstruct the states for terminals to the left of a
5.559 + syntax error, and attempt to make error corrections there.
5.560 +
5.561 + The queue consists of a pair of lists (x,y). New additions to
5.562 + the queue are cons'ed onto y. The first element of x is the top
5.563 + of the queue. If x is nil, then y is reversed and used
5.564 + in place of x.
5.565 +
5.566 + Algorithm:
5.567 + ----------
5.568 +
5.569 + * The steady-state parser:
5.570 +
5.571 + This parser keeps the length of the queue of state stacks at
5.572 + a steady state by always removing an element from the front when
5.573 + another element is placed on the end.
5.574 +
5.575 + It has these arguments:
5.576 +
5.577 + stack: current stack
5.578 + queue: value of the queue
5.579 + lexPair ((terminal,value),lex stream)
5.580 +
5.581 + When SHIFT is encountered, the state to shift to and the value are
5.582 + are pushed onto the state stack. The state stack and lexPair are
5.583 + placed on the queue. The front element of the queue is removed.
5.584 +
5.585 + When REDUCTION is encountered, the rule is applied to the current
5.586 + stack to yield a triple (nonterm,value,new stack). A new
5.587 + stack is formed by adding (goto(top state of stack,nonterm),value)
5.588 + to the stack.
5.589 +
5.590 + When ACCEPT is encountered, the top value from the stack and the
5.591 + lexer are returned.
5.592 +
5.593 + When an ERROR is encountered, fixError is called. FixError
5.594 + takes the arguments to the parser, fixes the error if possible and
5.595 + returns a new set of arguments.
5.596 +
5.597 + * The distance-parser:
5.598 +
5.599 + This parser includes an additional argument distance. It pushes
5.600 + elements on the queue until it has parsed distance tokens, or an
5.601 + ACCEPT or ERROR occurs. It returns a stack, lexer, the number of
5.602 + tokens left unparsed, a queue, and an action option.
5.603 +*)
5.604 +
5.605 +signature FIFO =
5.606 + sig type 'a queue
5.607 + val empty : 'a queue
5.608 + exception Empty
5.609 + val get : 'a queue -> 'a * 'a queue
5.610 + val put : 'a * 'a queue -> 'a queue
5.611 + end
5.612 +
5.613 +(* drt (12/15/89) -- the functor should be used in development work, but
5.614 + it wastes space in the release version.
5.615 +
5.616 +functor ParserGen(structure LrTable : LR_TABLE
5.617 + structure Stream : STREAM) : LR_PARSER =
5.618 +*)
5.619 +
5.620 +structure LrParser :> LR_PARSER =
5.621 + struct
5.622 + structure LrTable = LrTable
5.623 + structure Stream = Stream
5.624 +
5.625 + fun eqT (LrTable.T i, LrTable.T i') = i = i'
5.626 +
5.627 + structure Token : TOKEN =
5.628 + struct
5.629 + structure LrTable = LrTable
5.630 + datatype ('a,'b) token = TOKEN of LrTable.term * ('a * 'b * 'b)
5.631 + val sameToken = fn (TOKEN(t,_),TOKEN(t',_)) => eqT (t,t')
5.632 + end
5.633 +
5.634 + open LrTable
5.635 + open Token
5.636 +
5.637 + val DEBUG1 = false
5.638 + val DEBUG2 = false
5.639 + exception ParseError
5.640 + exception ParseImpossible of int
5.641 +
5.642 + structure Fifo :> FIFO =
5.643 + struct
5.644 + type 'a queue = ('a list * 'a list)
5.645 + val empty = (nil,nil)
5.646 + exception Empty
5.647 + fun get(a::x, y) = (a, (x,y))
5.648 + | get(nil, nil) = raise Empty
5.649 + | get(nil, y) = get(rev y, nil)
5.650 + fun put(a,(x,y)) = (x,a::y)
5.651 + end
5.652 +
5.653 + type ('a,'b) elem = (state * ('a * 'b * 'b))
5.654 + type ('a,'b) stack = ('a,'b) elem list
5.655 + type ('a,'b) lexv = ('a,'b) token
5.656 + type ('a,'b) lexpair = ('a,'b) lexv * (('a,'b) lexv Stream.stream)
5.657 + type ('a,'b) distanceParse =
5.658 + ('a,'b) lexpair *
5.659 + ('a,'b) stack *
5.660 + (('a,'b) stack * ('a,'b) lexpair) Fifo.queue *
5.661 + int ->
5.662 + ('a,'b) lexpair *
5.663 + ('a,'b) stack *
5.664 + (('a,'b) stack * ('a,'b) lexpair) Fifo.queue *
5.665 + int *
5.666 + action option
5.667 +
5.668 + type ('a,'b) ecRecord =
5.669 + {is_keyword : term -> bool,
5.670 + preferred_change : (term list * term list) list,
5.671 + error : string * 'b * 'b -> unit,
5.672 + errtermvalue : term -> 'a,
5.673 + terms : term list,
5.674 + showTerminal : term -> string,
5.675 + noShift : term -> bool}
5.676 +
5.677 + local
5.678 +
5.679 + val println = fn s => (TextIO.print s; TextIO.print "\n")
5.680 + val showState = fn (STATE s) => "STATE " ^ (Int.toString s)
5.681 + in
5.682 + fun printStack(stack: ('a,'b) stack, n: int) =
5.683 + case stack
5.684 + of (state,_) :: rest =>
5.685 + (TextIO.print("\t" ^ Int.toString n ^ ": ");
5.686 + println(showState state);
5.687 + printStack(rest, n+1))
5.688 + | nil => ()
5.689 +
5.690 + fun prAction showTerminal
5.691 + (stack as (state,_) :: _, next as (TOKEN (term,_),_), action) =
5.692 + (println "Parse: state stack:";
5.693 + printStack(stack, 0);
5.694 + TextIO.print(" state="
5.695 + ^ showState state
5.696 + ^ " next="
5.697 + ^ showTerminal term
5.698 + ^ " action="
5.699 + );
5.700 + case action
5.701 + of SHIFT state => println ("SHIFT " ^ (showState state))
5.702 + | REDUCE i => println ("REDUCE " ^ (Int.toString i))
5.703 + | ERROR => println "ERROR"
5.704 + | ACCEPT => println "ACCEPT")
5.705 + | prAction _ (_,_,action) = ()
5.706 + end
5.707 +
5.708 + (* ssParse: parser which maintains the queue of (state * lexvalues) in a
5.709 + steady-state. It takes a table, showTerminal function, saction
5.710 + function, and fixError function. It parses until an ACCEPT is
5.711 + encountered, or an exception is raised. When an error is encountered,
5.712 + fixError is called with the arguments of parseStep (lexv,stack,and
5.713 + queue). It returns the lexv, and a new stack and queue adjusted so
5.714 + that the lexv can be parsed *)
5.715 +
5.716 + val ssParse =
5.717 + fn (table,showTerminal,saction,fixError,arg) =>
5.718 + let val prAction = prAction showTerminal
5.719 + val action = LrTable.action table
5.720 + val goto = LrTable.goto table
5.721 + fun parseStep(args as
5.722 + (lexPair as (TOKEN (terminal, value as (_,leftPos,_)),
5.723 + lexer
5.724 + ),
5.725 + stack as (state,_) :: _,
5.726 + queue)) =
5.727 + let val nextAction = action (state,terminal)
5.728 + val _ = if DEBUG1 then prAction(stack,lexPair,nextAction)
5.729 + else ()
5.730 + in case nextAction
5.731 + of SHIFT s =>
5.732 + let val newStack = (s,value) :: stack
5.733 + val newLexPair = Stream.get lexer
5.734 + val (_,newQueue) =Fifo.get(Fifo.put((newStack,newLexPair),
5.735 + queue))
5.736 + in parseStep(newLexPair,(s,value)::stack,newQueue)
5.737 + end
5.738 + | REDUCE i =>
5.739 + (case saction(i,leftPos,stack,arg)
5.740 + of (nonterm,value,stack as (state,_) :: _) =>
5.741 + parseStep(lexPair,(goto(state,nonterm),value)::stack,
5.742 + queue)
5.743 + | _ => raise (ParseImpossible 197))
5.744 + | ERROR => parseStep(fixError args)
5.745 + | ACCEPT =>
5.746 + (case stack
5.747 + of (_,(topvalue,_,_)) :: _ =>
5.748 + let val (token,restLexer) = lexPair
5.749 + in (topvalue,Stream.cons(token,restLexer))
5.750 + end
5.751 + | _ => raise (ParseImpossible 202))
5.752 + end
5.753 + | parseStep _ = raise (ParseImpossible 204)
5.754 + in parseStep
5.755 + end
5.756 +
5.757 + (* distanceParse: parse until n tokens are shifted, or accept or
5.758 + error are encountered. Takes a table, showTerminal function, and
5.759 + semantic action function. Returns a parser which takes a lexPair
5.760 + (lex result * lexer), a state stack, a queue, and a distance
5.761 + (must be > 0) to parse. The parser returns a new lex-value, a stack
5.762 + with the nth token shifted on top, a queue, a distance, and action
5.763 + option. *)
5.764 +
5.765 + val distanceParse =
5.766 + fn (table,showTerminal,saction,arg) =>
5.767 + let val prAction = prAction showTerminal
5.768 + val action = LrTable.action table
5.769 + val goto = LrTable.goto table
5.770 + fun parseStep(lexPair,stack,queue,0) = (lexPair,stack,queue,0,NONE)
5.771 + | parseStep(lexPair as (TOKEN (terminal, value as (_,leftPos,_)),
5.772 + lexer
5.773 + ),
5.774 + stack as (state,_) :: _,
5.775 + queue,distance) =
5.776 + let val nextAction = action(state,terminal)
5.777 + val _ = if DEBUG1 then prAction(stack,lexPair,nextAction)
5.778 + else ()
5.779 + in case nextAction
5.780 + of SHIFT s =>
5.781 + let val newStack = (s,value) :: stack
5.782 + val newLexPair = Stream.get lexer
5.783 + in parseStep(newLexPair,(s,value)::stack,
5.784 + Fifo.put((newStack,newLexPair),queue),distance-1)
5.785 + end
5.786 + | REDUCE i =>
5.787 + (case saction(i,leftPos,stack,arg)
5.788 + of (nonterm,value,stack as (state,_) :: _) =>
5.789 + parseStep(lexPair,(goto(state,nonterm),value)::stack,
5.790 + queue,distance)
5.791 + | _ => raise (ParseImpossible 240))
5.792 + | ERROR => (lexPair,stack,queue,distance,SOME nextAction)
5.793 + | ACCEPT => (lexPair,stack,queue,distance,SOME nextAction)
5.794 + end
5.795 + | parseStep _ = raise (ParseImpossible 242)
5.796 + in parseStep : ('_a,'_b) distanceParse
5.797 + end
5.798 +
5.799 +(* mkFixError: function to create fixError function which adjusts parser state
5.800 + so that parse may continue in the presence of an error *)
5.801 +
5.802 +fun mkFixError({is_keyword,terms,errtermvalue,
5.803 + preferred_change,noShift,
5.804 + showTerminal,error,...} : ('_a,'_b) ecRecord,
5.805 + distanceParse : ('_a,'_b) distanceParse,
5.806 + minAdvance,maxAdvance)
5.807 +
5.808 + (lexv as (TOKEN (term,value as (_,leftPos,_)),_),stack,queue) =
5.809 + let val _ = if DEBUG2 then
5.810 + error("syntax error found at " ^ (showTerminal term),
5.811 + leftPos,leftPos)
5.812 + else ()
5.813 +
5.814 + fun tokAt(t,p) = TOKEN(t,(errtermvalue t,p,p))
5.815 +
5.816 + val minDelta = 3
5.817 +
5.818 + (* pull all the state * lexv elements from the queue *)
5.819 +
5.820 + val stateList =
5.821 + let fun f q = let val (elem,newQueue) = Fifo.get q
5.822 + in elem :: (f newQueue)
5.823 + end handle Fifo.Empty => nil
5.824 + in f queue
5.825 + end
5.826 +
5.827 + (* now number elements of stateList, giving distance from
5.828 + error token *)
5.829 +
5.830 + val (_, numStateList) =
5.831 + List.foldr (fn (a,(num,r)) => (num+1,(a,num)::r)) (0, []) stateList
5.832 +
5.833 + (* Represent the set of potential changes as a linked list.
5.834 +
5.835 + Values of datatype Change hold information about a potential change.
5.836 +
5.837 + oper = oper to be applied
5.838 + pos = the # of the element in stateList that would be altered.
5.839 + distance = the number of tokens beyond the error token which the
5.840 + change allows us to parse.
5.841 + new = new terminal * value pair at that point
5.842 + orig = original terminal * value pair at the point being changed.
5.843 + *)
5.844 +
5.845 + datatype ('a,'b) change = CHANGE of
5.846 + {pos : int, distance : int, leftPos: 'b, rightPos: 'b,
5.847 + new : ('a,'b) lexv list, orig : ('a,'b) lexv list}
5.848 +
5.849 +
5.850 + val showTerms = String.concat o map (fn TOKEN(t,_) => " " ^ showTerminal t)
5.851 +
5.852 + val printChange = fn c =>
5.853 + let val CHANGE {distance,new,orig,pos,...} = c
5.854 + in (TextIO.print ("{distance= " ^ (Int.toString distance));
5.855 + TextIO.print (",orig ="); TextIO.print(showTerms orig);
5.856 + TextIO.print (",new ="); TextIO.print(showTerms new);
5.857 + TextIO.print (",pos= " ^ (Int.toString pos));
5.858 + TextIO.print "}\n")
5.859 + end
5.860 +
5.861 + val printChangeList = app printChange
5.862 +
5.863 +(* parse: given a lexPair, a stack, and the distance from the error
5.864 + token, return the distance past the error token that we are able to parse.*)
5.865 +
5.866 + fun parse (lexPair,stack,queuePos : int) =
5.867 + case distanceParse(lexPair,stack,Fifo.empty,queuePos+maxAdvance+1)
5.868 + of (_,_,_,distance,SOME ACCEPT) =>
5.869 + if maxAdvance-distance-1 >= 0
5.870 + then maxAdvance
5.871 + else maxAdvance-distance-1
5.872 + | (_,_,_,distance,_) => maxAdvance - distance - 1
5.873 +
5.874 +(* catList: concatenate results of scanning list *)
5.875 +
5.876 + fun catList l f = List.foldr (fn(a,r)=> f a @ r) [] l
5.877 +
5.878 + fun keywordsDelta new = if List.exists (fn(TOKEN(t,_))=>is_keyword t) new
5.879 + then minDelta else 0
5.880 +
5.881 + fun tryChange{lex,stack,pos,leftPos,rightPos,orig,new} =
5.882 + let val lex' = List.foldr (fn (t',p)=>(t',Stream.cons p)) lex new
5.883 + val distance = parse(lex',stack,pos+length new-length orig)
5.884 + in if distance >= minAdvance + keywordsDelta new
5.885 + then [CHANGE{pos=pos,leftPos=leftPos,rightPos=rightPos,
5.886 + distance=distance,orig=orig,new=new}]
5.887 + else []
5.888 + end
5.889 +
5.890 +
5.891 +(* tryDelete: Try to delete n terminals.
5.892 + Return single-element [success] or nil.
5.893 + Do not delete unshiftable terminals. *)
5.894 +
5.895 +
5.896 + fun tryDelete n ((stack,lexPair as (TOKEN(term,(_,l,r)),_)),qPos) =
5.897 + let fun del(0,accum,left,right,lexPair) =
5.898 + tryChange{lex=lexPair,stack=stack,
5.899 + pos=qPos,leftPos=left,rightPos=right,
5.900 + orig=rev accum, new=[]}
5.901 + | del(n,accum,left,right,(tok as TOKEN(term,(_,_,r)),lexer)) =
5.902 + if noShift term then []
5.903 + else del(n-1,tok::accum,left,r,Stream.get lexer)
5.904 + in del(n,[],l,r,lexPair)
5.905 + end
5.906 +
5.907 +(* tryInsert: try to insert tokens before the current terminal;
5.908 + return a list of the successes *)
5.909 +
5.910 + fun tryInsert((stack,lexPair as (TOKEN(_,(_,l,_)),_)),queuePos) =
5.911 + catList terms (fn t =>
5.912 + tryChange{lex=lexPair,stack=stack,
5.913 + pos=queuePos,orig=[],new=[tokAt(t,l)],
5.914 + leftPos=l,rightPos=l})
5.915 +
5.916 +(* trySubst: try to substitute tokens for the current terminal;
5.917 + return a list of the successes *)
5.918 +
5.919 + fun trySubst ((stack,lexPair as (orig as TOKEN (term,(_,l,r)),lexer)),
5.920 + queuePos) =
5.921 + if noShift term then []
5.922 + else
5.923 + catList terms (fn t =>
5.924 + tryChange{lex=Stream.get lexer,stack=stack,
5.925 + pos=queuePos,
5.926 + leftPos=l,rightPos=r,orig=[orig],
5.927 + new=[tokAt(t,r)]})
5.928 +
5.929 + (* do_delete(toks,lexPair) tries to delete tokens "toks" from "lexPair".
5.930 + If it succeeds, returns SOME(toks',l,r,lp), where
5.931 + toks' is the actual tokens (with positions and values) deleted,
5.932 + (l,r) are the (leftmost,rightmost) position of toks',
5.933 + lp is what remains of the stream after deletion
5.934 + *)
5.935 + fun do_delete(nil,lp as (TOKEN(_,(_,l,_)),_)) = SOME(nil,l,l,lp)
5.936 + | do_delete([t],(tok as TOKEN(t',(_,l,r)),lp')) =
5.937 + if eqT (t, t')
5.938 + then SOME([tok],l,r,Stream.get lp')
5.939 + else NONE
5.940 + | do_delete(t::rest,(tok as TOKEN(t',(_,l,r)),lp')) =
5.941 + if eqT (t,t')
5.942 + then case do_delete(rest,Stream.get lp')
5.943 + of SOME(deleted,l',r',lp'') =>
5.944 + SOME(tok::deleted,l,r',lp'')
5.945 + | NONE => NONE
5.946 + else NONE
5.947 +
5.948 + fun tryPreferred((stack,lexPair),queuePos) =
5.949 + catList preferred_change (fn (delete,insert) =>
5.950 + if List.exists noShift delete then [] (* should give warning at
5.951 + parser-generation time *)
5.952 + else case do_delete(delete,lexPair)
5.953 + of SOME(deleted,l,r,lp) =>
5.954 + tryChange{lex=lp,stack=stack,pos=queuePos,
5.955 + leftPos=l,rightPos=r,orig=deleted,
5.956 + new=map (fn t=>(tokAt(t,r))) insert}
5.957 + | NONE => [])
5.958 +
5.959 + val changes = catList numStateList tryPreferred @
5.960 + catList numStateList tryInsert @
5.961 + catList numStateList trySubst @
5.962 + catList numStateList (tryDelete 1) @
5.963 + catList numStateList (tryDelete 2) @
5.964 + catList numStateList (tryDelete 3)
5.965 +
5.966 + val findMaxDist = fn l =>
5.967 + List.foldr (fn (CHANGE {distance,...},high) => Int.max(distance,high)) 0 l
5.968 +
5.969 +(* maxDist: max distance past error taken that we could parse *)
5.970 +
5.971 + val maxDist = findMaxDist changes
5.972 +
5.973 +(* remove changes which did not parse maxDist tokens past the error token *)
5.974 +
5.975 + val changes = catList changes
5.976 + (fn(c as CHANGE{distance,...}) =>
5.977 + if distance=maxDist then [c] else [])
5.978 +
5.979 + in case changes
5.980 + of (l as change :: _) =>
5.981 + let fun print_msg (CHANGE {new,orig,leftPos,rightPos,...}) =
5.982 + let val s =
5.983 + case (orig,new)
5.984 + of (_::_,[]) => "deleting " ^ (showTerms orig)
5.985 + | ([],_::_) => "inserting " ^ (showTerms new)
5.986 + | _ => "replacing " ^ (showTerms orig) ^
5.987 + " with " ^ (showTerms new)
5.988 + in error ("syntax error: " ^ s,leftPos,rightPos)
5.989 + end
5.990 +
5.991 + val _ =
5.992 + (if length l > 1 andalso DEBUG2 then
5.993 + (TextIO.print "multiple fixes possible; could fix it by:\n";
5.994 + app print_msg l;
5.995 + TextIO.print "chosen correction:\n")
5.996 + else ();
5.997 + print_msg change)
5.998 +
5.999 + (* findNth: find nth queue entry from the error
5.1000 + entry. Returns the Nth queue entry and the portion of
5.1001 + the queue from the beginning to the nth-1 entry. The
5.1002 + error entry is at the end of the queue.
5.1003 +
5.1004 + Examples:
5.1005 +
5.1006 + queue = a b c d e
5.1007 + findNth 0 = (e,a b c d)
5.1008 + findNth 1 = (d,a b c)
5.1009 + *)
5.1010 +
5.1011 + val findNth = fn n =>
5.1012 + let fun f (h::t,0) = (h,rev t)
5.1013 + | f (h::t,n) = f(t,n-1)
5.1014 + | f (nil,_) = let exception FindNth
5.1015 + in raise FindNth
5.1016 + end
5.1017 + in f (rev stateList,n)
5.1018 + end
5.1019 +
5.1020 + val CHANGE {pos,orig,new,...} = change
5.1021 + val (last,queueFront) = findNth pos
5.1022 + val (stack,lexPair) = last
5.1023 +
5.1024 + val lp1 = List.foldl(fn (_,(_,r)) => Stream.get r) lexPair orig
5.1025 + val lp2 = List.foldr(fn(t,r)=>(t,Stream.cons r)) lp1 new
5.1026 +
5.1027 + val restQueue =
5.1028 + Fifo.put((stack,lp2),
5.1029 + List.foldl Fifo.put Fifo.empty queueFront)
5.1030 +
5.1031 + val (lexPair,stack,queue,_,_) =
5.1032 + distanceParse(lp2,stack,restQueue,pos)
5.1033 +
5.1034 + in (lexPair,stack,queue)
5.1035 + end
5.1036 + | nil => (error("syntax error found at " ^ (showTerminal term),
5.1037 + leftPos,leftPos); raise ParseError)
5.1038 + end
5.1039 +
5.1040 + val parse = fn {arg,table,lexer,saction,void,lookahead,
5.1041 + ec=ec as {showTerminal,...} : ('_a,'_b) ecRecord} =>
5.1042 + let val distance = 15 (* defer distance tokens *)
5.1043 + val minAdvance = 1 (* must parse at least 1 token past error *)
5.1044 + val maxAdvance = Int.max(lookahead,0)(* max distance for parse check *)
5.1045 + val lexPair = Stream.get lexer
5.1046 + val (TOKEN (_,(_,leftPos,_)),_) = lexPair
5.1047 + val startStack = [(initialState table,(void,leftPos,leftPos))]
5.1048 + val startQueue = Fifo.put((startStack,lexPair),Fifo.empty)
5.1049 + val distanceParse = distanceParse(table,showTerminal,saction,arg)
5.1050 + val fixError = mkFixError(ec,distanceParse,minAdvance,maxAdvance)
5.1051 + val ssParse = ssParse(table,showTerminal,saction,fixError,arg)
5.1052 + fun loop (lexPair,stack,queue,_,SOME ACCEPT) =
5.1053 + ssParse(lexPair,stack,queue)
5.1054 + | loop (lexPair,stack,queue,0,_) = ssParse(lexPair,stack,queue)
5.1055 + | loop (lexPair,stack,queue,distance,SOME ERROR) =
5.1056 + let val (lexPair,stack,queue) = fixError(lexPair,stack,queue)
5.1057 + in loop (distanceParse(lexPair,stack,queue,distance))
5.1058 + end
5.1059 + | loop _ = let exception ParseInternal
5.1060 + in raise ParseInternal
5.1061 + end
5.1062 + in loop (distanceParse(lexPair,startStack,startQueue,distance))
5.1063 + end
5.1064 + end;
5.1065 +
5.1066 +;
5.1067 +print_depth 10;
6.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
6.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp.lex Fri Mar 09 15:38:55 2012 +0000
6.3 @@ -0,0 +1,185 @@
6.4 +(* Title: HOL/TPTP/TPTP_Parser/tptp.lex
6.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
6.6 +
6.7 + Notes:
6.8 + * Omit %full in definitions to restrict alphabet to ascii.
6.9 + * Could include %posarg to ensure that start counting character positions from
6.10 + 0, but it would punish performance.
6.11 + * %s AF F COMMENT; -- could improve by making stateful.
6.12 +
6.13 + Acknowledgements:
6.14 + * Geoff Sutcliffe for help with TPTP.
6.15 + * Timothy Bourke for his tips on getting ML-Yacc working with Poly/ML.
6.16 + * An early version of this was ported from the specification shipped with
6.17 + Leo-II, written by Frank Theiss.
6.18 + * Some boilerplate bits were taken from the ml-yacc/ml-lex manual by Roger Price.
6.19 + * Jasmin Blanchette and Makarius Wenzel for help with Isabelle integration.
6.20 +*)
6.21 +
6.22 +structure T = Tokens
6.23 +type pos = int (* Position in file *)
6.24 +type lineNo = int
6.25 +type svalue = T.svalue
6.26 +type ('a,'b) token = ('a,'b) T.token
6.27 +type lexresult = (svalue,pos) token
6.28 +type lexarg = string
6.29 +type arg = lexarg
6.30 +val col = ref 0;
6.31 +val linep = ref 1; (* Line pointer *)
6.32 +val eolpos = ref 0;
6.33 +
6.34 +val badCh : string * string * int * int -> unit = fn
6.35 + (file_name, bad, line, col) =>
6.36 + TextIO.output(TextIO.stdOut, file_name ^ "["
6.37 + ^ Int.toString line ^ "." ^ Int.toString col
6.38 + ^ "] Invalid character \"" ^ bad ^ "\"\n");
6.39 +
6.40 +val eof = fn file_name =>
6.41 + let
6.42 + val result = T.EOF (!linep,!col);
6.43 + val _ = linep := 0;
6.44 + in result end
6.45 +(*here could check whether file ended prematurely:
6.46 + see if have open brackets, or if we're in some state other than INITIAL*)
6.47 +
6.48 +val count_commentlines : string -> unit = fn str =>
6.49 + let
6.50 + val str' = String.explode str
6.51 + val newlines = List.filter (fn x => x = #"\n") str'
6.52 + in linep := (!linep) + (List.length newlines) end
6.53 +
6.54 +%%
6.55 +%header (functor TPTPLexFun(structure Tokens: TPTP_TOKENS));
6.56 +%arg (file_name:string);
6.57 +
6.58 +printable_char = .;
6.59 +viewable_char = [.\n];
6.60 +numeric = [0-9];
6.61 +lower_alpha = [a-z];
6.62 +upper_alpha = [A-Z];
6.63 +alpha_numeric = ({lower_alpha}|{upper_alpha}|{numeric}|_);
6.64 +zero_numeric = [0];
6.65 +non_zero_numeric = [1-9];
6.66 +slash = [/];
6.67 +exponent = [Ee];
6.68 +dot = [.];
6.69 +any_char = [^\n];
6.70 +dollar = \$;
6.71 +ddollar = \$\$;
6.72 +unsigned_integer = {numeric}+;
6.73 +sign = [+-];
6.74 +divide = [/];
6.75 +
6.76 +signed_integer = {sign}{unsigned_integer};
6.77 +dot_decimal = {dot}{numeric}+;
6.78 +exp_suffix = {exponent}({signed_integer}|{unsigned_integer});
6.79 +real = ({signed_integer}|{unsigned_integer}){dot_decimal}{exp_suffix}?;
6.80 +upper_word = {upper_alpha}{alpha_numeric}*;
6.81 +rational = ({signed_integer}|{unsigned_integer}){divide}{unsigned_integer};
6.82 +
6.83 +percentage_sign = "%";
6.84 +
6.85 +sq_char = ([\040-\041\043-\126]|[\\]['\\]);
6.86 +
6.87 +ws = ([\ ]|[\t]);
6.88 +eol = ("\013\010"|"\010"|"\013");
6.89 +
6.90 +single_quote = ['];
6.91 +single_quoted = {single_quote}({alpha_numeric}|{sq_char}|{ws})+{single_quote};
6.92 +
6.93 +lower_word = {lower_alpha}{alpha_numeric}*;
6.94 +atomic_system_word = {ddollar}{lower_word};
6.95 +atomic_defined_word = {dollar}{lower_word};
6.96 +
6.97 +system_comment_one = [%][\ ]*{ddollar}[_]*;
6.98 +system_comment_multi = [/][\*][\ ]*(ddollar)([^\*]*[\*][\*]*[^/\*])*[^\*]*[\*][\*]*[/];
6.99 +system_comment = (system_comment_one)|(system_comment_multi);
6.100 +comment_one = {percentage_sign}[^\n]*;
6.101 +comment_multi = [/][\*]([^\*]*[\*]+[^/\*])*[^\*]*[\*]+[/];
6.102 +comment = ({comment_one}|{comment_multi})+;
6.103 +
6.104 +do_char = ([^"]|[\\]["\\]);
6.105 +double_quote = ["];
6.106 +distinct_object = {double_quote}{do_char}+{double_quote};
6.107 +
6.108 +%%
6.109 +
6.110 +{ws}* => (col:=(!col)+size yytext; continue () );
6.111 +
6.112 +{eol} => (linep:=(!linep)+1;
6.113 + eolpos:=yypos+size yytext; continue ());
6.114 +
6.115 +"&" => (col:=yypos-(!eolpos); T.AMPERSAND(!linep,!col));
6.116 +
6.117 +"@+" => (col:=yypos-(!eolpos); T.INDEF_CHOICE(!linep,!col));
6.118 +"@-" => (col:=yypos-(!eolpos); T.DEFIN_CHOICE(!linep,!col));
6.119 +
6.120 +"!!" => (col:=yypos-(!eolpos); T.OPERATOR_FORALL(!linep,!col));
6.121 +"??" => (col:=yypos-(!eolpos); T.OPERATOR_EXISTS(!linep,!col));
6.122 +
6.123 +"@" => (col:=yypos-(!eolpos); T.AT_SIGN(!linep,!col));
6.124 +"^" => (col:=yypos-(!eolpos); T.CARET(!linep,!col));
6.125 +
6.126 +":" => (col:=yypos-(!eolpos); T.COLON(!linep,!col));
6.127 +"," => (col:=yypos-(!eolpos); T.COMMA(!linep,!col));
6.128 +"=" => (col:=yypos-(!eolpos); T.EQUALS(!linep,!col));
6.129 +"!" => (col:=yypos-(!eolpos); T.EXCLAMATION(!linep,!col));
6.130 +":=" => (col:=yypos-(!eolpos); T.LET(!linep,!col));
6.131 +">" => (col:=yypos-(!eolpos); T.ARROW(!linep,!col));
6.132 +
6.133 +"<=" => (col:=yypos-(!eolpos); T.IF(!linep,!col));
6.134 +"<=>" => (col:=yypos-(!eolpos); T.IFF(!linep,!col));
6.135 +"=>" => (col:=yypos-(!eolpos); T.IMPLIES(!linep,!col));
6.136 +"[" => (col:=yypos-(!eolpos); T.LBRKT(!linep,!col));
6.137 +"(" => (col:=yypos-(!eolpos); T.LPAREN(!linep,!col));
6.138 +"->" => (col:=yypos-(!eolpos); T.MAP_TO(!linep,!col));
6.139 +"--" => (col:=yypos-(!eolpos); T.MMINUS(!linep,!col));
6.140 +"~&" => (col:=yypos-(!eolpos); T.NAND(!linep,!col));
6.141 +"!=" => (col:=yypos-(!eolpos); T.NEQUALS(!linep,!col));
6.142 +"<~>" => (col:=yypos-(!eolpos); T.XOR(!linep,!col));
6.143 +"~|" => (col:=yypos-(!eolpos); T.NOR(!linep,!col));
6.144 +"." => (col:=yypos-(!eolpos); T.PERIOD(!linep,!col));
6.145 +"++" => (col:=yypos-(!eolpos); T.PPLUS(!linep,!col));
6.146 +"?" => (col:=yypos-(!eolpos); T.QUESTION(!linep,!col));
6.147 +"]" => (col:=yypos-(!eolpos); T.RBRKT(!linep,!col));
6.148 +")" => (col:=yypos-(!eolpos); T.RPAREN(!linep,!col));
6.149 +"~" => (col:=yypos-(!eolpos); T.TILDE(!linep,!col));
6.150 +"|" => (col:=yypos-(!eolpos); T.VLINE(!linep,!col));
6.151 +
6.152 +{distinct_object} => (col:=yypos-(!eolpos); T.DISTINCT_OBJECT(yytext,!linep,!col));
6.153 +{rational} => (col:=yypos-(!eolpos); T.RATIONAL(yytext,!linep,!col));
6.154 +{real} => (col:=yypos-(!eolpos); T.REAL(yytext,!linep,!col));
6.155 +{signed_integer} => (col:=yypos-(!eolpos); T.SIGNED_INTEGER(yytext,!linep,!col));
6.156 +{unsigned_integer} => (col:=yypos-(!eolpos); T.UNSIGNED_INTEGER(yytext,!linep,!col));
6.157 +{dot_decimal} => (col:=yypos-(!eolpos); T.DOT_DECIMAL(yytext,!linep,!col));
6.158 +{single_quoted} => (col:=yypos-(!eolpos); T.SINGLE_QUOTED(yytext,!linep,!col));
6.159 +{upper_word} => (col:=yypos-(!eolpos); T.UPPER_WORD(yytext,!linep,!col));
6.160 +{comment} => (col:=yypos-(!eolpos); count_commentlines yytext;T.COMMENT(yytext,!linep,!col));
6.161 +
6.162 +"thf" => (col:=yypos-(!eolpos); T.THF(!linep,!col));
6.163 +"fof" => (col:=yypos-(!eolpos); T.FOF(!linep,!col));
6.164 +"cnf" => (col:=yypos-(!eolpos); T.CNF(!linep,!col));
6.165 +"tff" => (col:=yypos-(!eolpos); T.TFF(!linep,!col));
6.166 +"include" => (col:=yypos-(!eolpos); T.INCLUDE(!linep,!col));
6.167 +
6.168 +"$thf" => (col:=yypos-(!eolpos); T.DTHF(!linep,!col));
6.169 +"$fof" => (col:=yypos-(!eolpos); T.DFOF(!linep,!col));
6.170 +"$cnf" => (col:=yypos-(!eolpos); T.DCNF(!linep,!col));
6.171 +"$fot" => (col:=yypos-(!eolpos); T.DFOT(!linep,!col));
6.172 +"$tff" => (col:=yypos-(!eolpos); T.DTFF(!linep,!col));
6.173 +
6.174 +"$ite_f" => (col:=yypos-(!eolpos); T.ITE_F(!linep,!col));
6.175 +"$ite_t" => (col:=yypos-(!eolpos); T.ITE_T(!linep,!col));
6.176 +
6.177 +{lower_word} => (col:=yypos-(!eolpos); T.LOWER_WORD(yytext,!linep,!col));
6.178 +{atomic_system_word} => (col:=yypos-(!eolpos); T.ATOMIC_SYSTEM_WORD(yytext,!linep,!col));
6.179 +{atomic_defined_word} => (col:=yypos-(!eolpos); T.ATOMIC_DEFINED_WORD(yytext,!linep,!col));
6.180 +
6.181 +"+" => (col:=yypos-(!eolpos); T.PLUS(!linep,!col));
6.182 +"*" => (col:=yypos-(!eolpos); T.TIMES(!linep,!col));
6.183 +"-->" => (col:=yypos-(!eolpos); T.GENTZEN_ARROW(!linep,!col));
6.184 +"<<" => (col:=yypos-(!eolpos); T.SUBTYPE(!linep,!col));
6.185 +"!>" => (col:=yypos-(!eolpos); T.DEP_PROD(!linep,!col));
6.186 +"?*" => (col:=yypos-(!eolpos); T.DEP_SUM(!linep,!col));
6.187 +
6.188 +":-" => (col:=yypos-(!eolpos); T.LET_TERM(!linep,!col));
7.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
7.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp.yacc Fri Mar 09 15:38:55 2012 +0000
7.3 @@ -0,0 +1,653 @@
7.4 +open TPTP_Syntax
7.5 +
7.6 +exception UNRECOGNISED_SYMBOL of string * string
7.7 +
7.8 +exception UNRECOGNISED_ROLE of string
7.9 +fun classify_role role =
7.10 + case role of
7.11 + "axiom" => Role_Axiom
7.12 + | "hypothesis" => Role_Hypothesis
7.13 + | "definition" => Role_Definition
7.14 + | "assumption" => Role_Assumption
7.15 + | "lemma" => Role_Lemma
7.16 + | "theorem" => Role_Theorem
7.17 + | "conjecture" => Role_Conjecture
7.18 + | "negated_conjecture" => Role_Negated_Conjecture
7.19 + | "plain" => Role_Plain
7.20 + | "fi_domain" => Role_Fi_Domain
7.21 + | "fi_functors" => Role_Fi_Functors
7.22 + | "fi_predicates" => Role_Fi_Predicates
7.23 + | "type" => Role_Type
7.24 + | "unknown" => Role_Unknown
7.25 + | thing => raise (UNRECOGNISED_ROLE thing)
7.26 +
7.27 +%%
7.28 +%name TPTP
7.29 +%term AMPERSAND | AT_SIGN | CARET | COLON | COMMA | EQUALS | EXCLAMATION
7.30 + | LET | ARROW | IF | IFF | IMPLIES | INCLUDE
7.31 + | LAMBDA | LBRKT | LPAREN | MAP_TO | MMINUS | NAND
7.32 + | NEQUALS | XOR | NOR | PERIOD | PPLUS | QUESTION | RBRKT | RPAREN
7.33 + | TILDE | TOK_FALSE | TOK_I | TOK_O | TOK_INT | TOK_REAL | TOK_RAT | TOK_TRUE
7.34 + | TOK_TYPE | VLINE | EOF | DTHF | DFOF | DCNF | DFOT | DTFF | REAL of string
7.35 + | RATIONAL of string | SIGNED_INTEGER of string | UNSIGNED_INTEGER of string
7.36 + | DOT_DECIMAL of string | SINGLE_QUOTED of string | UPPER_WORD of string
7.37 + | LOWER_WORD of string | COMMENT of string
7.38 + | DISTINCT_OBJECT of string
7.39 + | DUD | INDEF_CHOICE | DEFIN_CHOICE
7.40 + | OPERATOR_FORALL | OPERATOR_EXISTS
7.41 + | PLUS | TIMES | GENTZEN_ARROW | DEP_SUM | DEP_PROD
7.42 + | ATOMIC_DEFINED_WORD of string | ATOMIC_SYSTEM_WORD of string
7.43 + | SUBTYPE | LET_TERM
7.44 + | THF | TFF | FOF | CNF
7.45 + | ITE_F | ITE_T
7.46 +%nonterm
7.47 + annotations of annotation option
7.48 + | name of string
7.49 + | name_list of string list
7.50 + | formula_selection of string list
7.51 + | optional_info of general_term list
7.52 + | general_list of general_list | general_terms of general_term list
7.53 + | general_term of general_term
7.54 +
7.55 + | atomic_word of string
7.56 + | general_data of general_data | variable_ of string
7.57 + | number of number_kind * string | formula_data of general_data
7.58 + | integer of string
7.59 + | identifier of string
7.60 + | general_function of general_data | useful_info of general_list
7.61 + | file_name of string
7.62 + | functor_ of symbol
7.63 + | term of tptp_term
7.64 + | arguments of tptp_term list
7.65 + | defined_functor of symbol
7.66 + | system_functor of symbol
7.67 + | system_constant of symbol
7.68 + | system_term of symbol * tptp_term list
7.69 + | defined_constant of symbol
7.70 + | defined_plain_term of symbol * tptp_term list
7.71 + | defined_atomic_term of tptp_term
7.72 + | defined_atom of tptp_term
7.73 + | defined_term of tptp_term
7.74 + | constant of symbol
7.75 + | plain_term of symbol * tptp_term list
7.76 + | function_term of tptp_term
7.77 + | conditional_term of tptp_term
7.78 + | system_atomic_formula of tptp_formula
7.79 + | infix_equality of symbol
7.80 + | infix_inequality of symbol
7.81 + | defined_infix_pred of symbol
7.82 + | defined_infix_formula of tptp_formula
7.83 + | defined_prop of string
7.84 + | defined_pred of string
7.85 + | defined_plain_formula of tptp_formula
7.86 + | defined_atomic_formula of tptp_formula
7.87 + | plain_atomic_formula of tptp_formula
7.88 + | atomic_formula of tptp_formula
7.89 + | unary_connective of symbol
7.90 +
7.91 + | defined_type of tptp_base_type
7.92 + | system_type of string
7.93 + | assoc_connective of symbol
7.94 + | binary_connective of symbol
7.95 + | fol_quantifier of quantifier
7.96 + | thf_unary_connective of symbol
7.97 + | thf_pair_connective of symbol
7.98 + | thf_quantifier of quantifier
7.99 + | fol_infix_unary of tptp_formula
7.100 + | thf_conn_term of symbol
7.101 + | literal of tptp_formula
7.102 + | disjunction of tptp_formula
7.103 + | cnf_formula of tptp_formula
7.104 + | fof_tuple_list of tptp_formula list
7.105 + | fof_tuple of tptp_formula list
7.106 + | fof_sequent of tptp_formula
7.107 + | fof_unary_formula of tptp_formula
7.108 + | fof_variable_list of string list
7.109 + | fof_quantified_formula of tptp_formula
7.110 + | fof_unitary_formula of tptp_formula
7.111 + | fof_and_formula of tptp_formula
7.112 + | fof_or_formula of tptp_formula
7.113 + | fof_binary_assoc of tptp_formula
7.114 + | fof_binary_nonassoc of tptp_formula
7.115 + | fof_binary_formula of tptp_formula
7.116 + | fof_logic_formula of tptp_formula
7.117 + | fof_formula of tptp_formula
7.118 + | tff_tuple of tptp_formula list
7.119 + | tff_tuple_list of tptp_formula list
7.120 + | tff_sequent of tptp_formula
7.121 + | tff_conditional of tptp_formula
7.122 + | tff_defined_var of tptp_let
7.123 + | tff_let_list of tptp_let list
7.124 + | tptp_let of tptp_formula
7.125 + | tff_xprod_type of tptp_type
7.126 + | tff_mapping_type of tptp_type
7.127 + | tff_atomic_type of tptp_type
7.128 + | tff_unitary_type of tptp_type
7.129 + | tff_top_level_type of tptp_type
7.130 + | tff_untyped_atom of symbol * tptp_type option
7.131 + | tff_typed_atom of symbol * tptp_type option
7.132 + | tff_unary_formula of tptp_formula
7.133 + | tff_typed_variable of string * tptp_type option
7.134 + | tff_variable of string * tptp_type option
7.135 + | tff_variable_list of (string * tptp_type option) list
7.136 + | tff_quantified_formula of tptp_formula
7.137 + | tff_unitary_formula of tptp_formula
7.138 + | tff_and_formula of tptp_formula
7.139 + | tff_or_formula of tptp_formula
7.140 + | tff_binary_assoc of tptp_formula
7.141 + | tff_binary_nonassoc of tptp_formula
7.142 + | tff_binary_formula of tptp_formula
7.143 + | tff_logic_formula of tptp_formula
7.144 + | tff_formula of tptp_formula
7.145 +
7.146 + | thf_tuple of tptp_formula list
7.147 + | thf_tuple_list of tptp_formula list
7.148 + | thf_sequent of tptp_formula
7.149 + | thf_conditional of tptp_formula
7.150 + | thf_defined_var of tptp_let
7.151 + | thf_let_list of tptp_let list
7.152 + | thf_let of tptp_formula
7.153 + | thf_atom of tptp_formula
7.154 + | thf_union_type of tptp_type
7.155 + | thf_xprod_type of tptp_type
7.156 + | thf_mapping_type of tptp_type
7.157 + | thf_binary_type of tptp_type
7.158 + | thf_unitary_type of tptp_type
7.159 + | thf_top_level_type of tptp_type
7.160 + | thf_subtype of tptp_type
7.161 + | thf_typeable_formula of tptp_formula
7.162 + | thf_type_formula of tptp_formula * tptp_type
7.163 + | thf_unary_formula of tptp_formula
7.164 + | thf_typed_variable of string * tptp_type option
7.165 + | thf_variable of string * tptp_type option
7.166 + | thf_variable_list of (string * tptp_type option) list
7.167 + | thf_quantified_formula of tptp_formula
7.168 + | thf_unitary_formula of tptp_formula
7.169 + | thf_apply_formula of tptp_formula
7.170 + | thf_and_formula of tptp_formula
7.171 + | thf_or_formula of tptp_formula
7.172 + | thf_binary_tuple of tptp_formula
7.173 + | thf_binary_pair of tptp_formula
7.174 + | thf_binary_formula of tptp_formula
7.175 + | thf_logic_formula of tptp_formula
7.176 + | thf_formula of tptp_formula
7.177 + | formula_role of role
7.178 +
7.179 + | cnf_annotated of tptp_line
7.180 + | fof_annotated of tptp_line
7.181 + | tff_annotated of tptp_line
7.182 + | thf_annotated of tptp_line
7.183 + | annotated_formula of tptp_line
7.184 + | include_ of tptp_line
7.185 + | tptp_input of tptp_line
7.186 + | tptp_file of tptp_problem
7.187 + | tptp of tptp_problem
7.188 +
7.189 +%pos int
7.190 +%eop EOF
7.191 +%noshift EOF
7.192 +%arg (file_name) : string
7.193 +
7.194 +%nonassoc LET
7.195 +%nonassoc RPAREN
7.196 +%nonassoc DUD
7.197 +%right COMMA
7.198 +%left COLON
7.199 +
7.200 +%left AT_SIGN
7.201 +%nonassoc IFF XOR
7.202 +%right IMPLIES IF
7.203 +%nonassoc EQUALS NEQUALS
7.204 +%right VLINE NOR
7.205 +%left AMPERSAND NAND
7.206 +%right ARROW
7.207 +%left PLUS
7.208 +%left TIMES
7.209 +
7.210 +%right OPERATOR_FORALL OPERATOR_EXISTS
7.211 +
7.212 +%nonassoc EXCLAMATION QUESTION LAMBDA CARET
7.213 +%nonassoc TILDE
7.214 +%pure
7.215 +%start tptp
7.216 +%verbose
7.217 +%%
7.218 +
7.219 +(* Title: HOL/TPTP/TPTP_Parser/tptp.yacc
7.220 + Author: Nik Sultana, Cambridge University Computer Laboratory
7.221 +
7.222 + Parser for TPTP languages. Latest version of the language spec can
7.223 + be obtained from http://www.cs.miami.edu/~tptp/TPTP/SyntaxBNF.html
7.224 +*)
7.225 +
7.226 +annotations : COMMA general_term optional_info (( SOME (general_term, optional_info) ))
7.227 + | (( NONE ))
7.228 +
7.229 +optional_info : COMMA useful_info (( useful_info ))
7.230 + | (( [] ))
7.231 +
7.232 +useful_info : general_list (( general_list ))
7.233 +
7.234 +general_list : LBRKT general_terms RBRKT (( general_terms ))
7.235 + | LBRKT RBRKT (( [] ))
7.236 +
7.237 +general_terms : general_term COMMA general_terms (( general_term :: general_terms ))
7.238 + | general_term (( [general_term] ))
7.239 +
7.240 +general_term : general_data (( General_Data general_data ))
7.241 + | general_data COLON general_term (( General_Term (general_data, general_term) ))
7.242 + | general_list (( General_List general_list ))
7.243 +
7.244 +atomic_word : LOWER_WORD (( LOWER_WORD ))
7.245 + | SINGLE_QUOTED (( SINGLE_QUOTED ))
7.246 + | THF (( "thf" ))
7.247 + | TFF (( "tff" ))
7.248 + | FOF (( "fof" ))
7.249 + | CNF (( "cnf" ))
7.250 + | INCLUDE (( "include" ))
7.251 +
7.252 +variable_ : UPPER_WORD (( UPPER_WORD ))
7.253 +
7.254 +general_function: atomic_word LPAREN general_terms RPAREN (( Application (atomic_word, general_terms) ))
7.255 +
7.256 +general_data : atomic_word (( Atomic_Word atomic_word ))
7.257 + | general_function (( general_function ))
7.258 + | variable_ (( V variable_ ))
7.259 + | number (( Number number ))
7.260 + | DISTINCT_OBJECT (( Distinct_Object DISTINCT_OBJECT ))
7.261 + | formula_data (( formula_data ))
7.262 +
7.263 +number : integer (( (Int_num, integer) ))
7.264 + | REAL (( (Real_num, REAL) ))
7.265 + | RATIONAL (( (Rat_num, RATIONAL) ))
7.266 +
7.267 +integer: UNSIGNED_INTEGER (( UNSIGNED_INTEGER ))
7.268 + | SIGNED_INTEGER (( SIGNED_INTEGER ))
7.269 +
7.270 +file_name : SINGLE_QUOTED (( SINGLE_QUOTED ))
7.271 +
7.272 +formula_data : DTHF LPAREN thf_formula RPAREN (( Formula_Data (THF, thf_formula) ))
7.273 + | DTFF LPAREN tff_formula RPAREN (( Formula_Data (TFF, tff_formula) ))
7.274 + | DFOF LPAREN fof_formula RPAREN (( Formula_Data (FOF, fof_formula) ))
7.275 + | DCNF LPAREN cnf_formula RPAREN (( Formula_Data (CNF, cnf_formula) ))
7.276 + | DFOT LPAREN term RPAREN (( Term_Data term ))
7.277 +
7.278 +system_type : ATOMIC_SYSTEM_WORD (( ATOMIC_SYSTEM_WORD ))
7.279 +
7.280 +defined_type : ATOMIC_DEFINED_WORD ((
7.281 + case ATOMIC_DEFINED_WORD of
7.282 + "$i" => Type_Ind
7.283 + | "$o" => Type_Bool
7.284 + | "$iType" => Type_Ind
7.285 + | "$oType" => Type_Bool
7.286 + | "$int" => Type_Int
7.287 + | "$real" => Type_Real
7.288 + | "$rat" => Type_Rat
7.289 + | "$tType" => Type_Type
7.290 + | thing => raise UNRECOGNISED_SYMBOL ("defined_type", thing)
7.291 +))
7.292 +
7.293 +functor_ : atomic_word (( Uninterpreted atomic_word ))
7.294 +
7.295 +arguments : term (( [term] ))
7.296 + | term COMMA arguments (( term :: arguments ))
7.297 +
7.298 +system_functor : ATOMIC_SYSTEM_WORD (( System ATOMIC_SYSTEM_WORD ))
7.299 +system_constant : system_functor (( system_functor ))
7.300 +system_term : system_constant (( (system_constant, []) ))
7.301 + | system_functor LPAREN arguments RPAREN (( (system_functor, arguments) ))
7.302 +
7.303 +defined_functor : ATOMIC_DEFINED_WORD ((
7.304 + case ATOMIC_DEFINED_WORD of
7.305 + "$sum" => Interpreted_ExtraLogic Sum
7.306 + | "$difference" => Interpreted_ExtraLogic Difference
7.307 + | "$product" => Interpreted_ExtraLogic Product
7.308 + | "$quotient" => Interpreted_ExtraLogic Quotient
7.309 + | "$quotient_e" => Interpreted_ExtraLogic Quotient_E
7.310 + | "$quotient_t" => Interpreted_ExtraLogic Quotient_T
7.311 + | "$quotient_f" => Interpreted_ExtraLogic Quotient_F
7.312 + | "$remainder_e" => Interpreted_ExtraLogic Remainder_E
7.313 + | "$remainder_t" => Interpreted_ExtraLogic Remainder_T
7.314 + | "$remainder_f" => Interpreted_ExtraLogic Remainder_F
7.315 + | "$floor" => Interpreted_ExtraLogic Floor
7.316 + | "$ceiling" => Interpreted_ExtraLogic Ceiling
7.317 + | "$truncate" => Interpreted_ExtraLogic Truncate
7.318 + | "$round" => Interpreted_ExtraLogic Round
7.319 + | "$to_int" => Interpreted_ExtraLogic To_Int
7.320 + | "$to_rat" => Interpreted_ExtraLogic To_Rat
7.321 + | "$to_real" => Interpreted_ExtraLogic To_Real
7.322 + | "$uminus" => Interpreted_ExtraLogic UMinus
7.323 +
7.324 + | "$i" => TypeSymbol Type_Ind
7.325 + | "$o" => TypeSymbol Type_Bool
7.326 + | "$iType" => TypeSymbol Type_Ind
7.327 + | "$oType" => TypeSymbol Type_Bool
7.328 + | "$int" => TypeSymbol Type_Int
7.329 + | "$real" => TypeSymbol Type_Real
7.330 + | "$rat" => TypeSymbol Type_Rat
7.331 + | "$tType" => TypeSymbol Type_Type
7.332 +
7.333 + | "$true" => Interpreted_Logic True
7.334 + | "$false" => Interpreted_Logic False
7.335 +
7.336 + | "$less" => Interpreted_ExtraLogic Less
7.337 + | "$lesseq" => Interpreted_ExtraLogic LessEq
7.338 + | "$greatereq" => Interpreted_ExtraLogic GreaterEq
7.339 + | "$greater" => Interpreted_ExtraLogic Greater
7.340 + | "$evaleq" => Interpreted_ExtraLogic EvalEq
7.341 +
7.342 + | "$is_int" => Interpreted_ExtraLogic Is_Int
7.343 + | "$is_rat" => Interpreted_ExtraLogic Is_Rat
7.344 +
7.345 + | thing => raise UNRECOGNISED_SYMBOL ("defined_functor", thing)
7.346 +))
7.347 +
7.348 +defined_constant : defined_functor (( defined_functor ))
7.349 +
7.350 +defined_plain_term : defined_constant (( (defined_constant, []) ))
7.351 + | defined_functor LPAREN arguments RPAREN (( (defined_functor, arguments) ))
7.352 +defined_atomic_term : defined_plain_term (( Term_Func defined_plain_term ))
7.353 +defined_atom : number (( Term_Num number ))
7.354 + | DISTINCT_OBJECT (( Term_Distinct_Object DISTINCT_OBJECT ))
7.355 +defined_term : defined_atom (( defined_atom ))
7.356 + | defined_atomic_term (( defined_atomic_term ))
7.357 +constant : functor_ (( functor_ ))
7.358 +plain_term : constant (( (constant, []) ))
7.359 + | functor_ LPAREN arguments RPAREN (( (functor_, arguments) ))
7.360 +function_term : plain_term (( Term_Func plain_term ))
7.361 + | defined_term (( defined_term ))
7.362 + | system_term (( Term_Func system_term ))
7.363 +
7.364 +conditional_term : ITE_T LPAREN tff_logic_formula COMMA term COMMA term RPAREN ((
7.365 + Term_Conditional (tff_logic_formula, term1, term2)
7.366 +))
7.367 +
7.368 +term : function_term (( function_term ))
7.369 + | variable_ (( Term_Var variable_ ))
7.370 + | conditional_term (( conditional_term ))
7.371 +
7.372 +system_atomic_formula : system_term (( Pred system_term ))
7.373 +infix_equality : EQUALS (( Interpreted_Logic Equals ))
7.374 +infix_inequality : NEQUALS (( Interpreted_Logic NEquals ))
7.375 +defined_infix_pred : infix_equality (( infix_equality ))
7.376 +defined_infix_formula : term defined_infix_pred term ((Pred (defined_infix_pred, [term1, term2])))
7.377 +defined_prop : ATOMIC_DEFINED_WORD ((
7.378 + case ATOMIC_DEFINED_WORD of
7.379 + "$true" => "$true"
7.380 + | "$false" => "$false"
7.381 + | thing => raise UNRECOGNISED_SYMBOL ("defined_prop", thing)
7.382 +))
7.383 +defined_pred : ATOMIC_DEFINED_WORD ((
7.384 + case ATOMIC_DEFINED_WORD of
7.385 + "$distinct" => "$distinct"
7.386 + | "$ite_f" => "$ite_f"
7.387 + | "$less" => "$less"
7.388 + | "$lesseq" => "$lesseq"
7.389 + | "$greater" => "$greater"
7.390 + | "$greatereq" => "$greatereq"
7.391 + | "$is_int" => "$is_int"
7.392 + | "$is_rat" => "$is_rat"
7.393 + | thing => raise UNRECOGNISED_SYMBOL ("defined_pred", thing)
7.394 +))
7.395 +defined_plain_formula : defined_plain_term (( Pred defined_plain_term ))
7.396 +defined_atomic_formula : defined_plain_formula (( defined_plain_formula ))
7.397 + | defined_infix_formula (( defined_infix_formula ))
7.398 +plain_atomic_formula : plain_term (( Pred plain_term ))
7.399 +atomic_formula : plain_atomic_formula (( plain_atomic_formula ))
7.400 + | defined_atomic_formula (( defined_atomic_formula ))
7.401 + | system_atomic_formula (( system_atomic_formula ))
7.402 +
7.403 +assoc_connective : VLINE (( Interpreted_Logic Or ))
7.404 + | AMPERSAND (( Interpreted_Logic And ))
7.405 +binary_connective : IFF (( Interpreted_Logic Iff ))
7.406 + | IMPLIES (( Interpreted_Logic If ))
7.407 + | IF (( Interpreted_Logic Fi ))
7.408 + | XOR (( Interpreted_Logic Xor ))
7.409 + | NOR (( Interpreted_Logic Nor ))
7.410 + | NAND (( Interpreted_Logic Nand ))
7.411 +
7.412 +fol_quantifier : EXCLAMATION (( Forall ))
7.413 + | QUESTION (( Exists ))
7.414 +thf_unary_connective : unary_connective (( unary_connective ))
7.415 + | OPERATOR_FORALL (( Interpreted_Logic Op_Forall ))
7.416 + | OPERATOR_EXISTS (( Interpreted_Logic Op_Exists ))
7.417 +thf_pair_connective : infix_equality (( infix_equality ))
7.418 + | infix_inequality (( infix_inequality ))
7.419 + | binary_connective (( binary_connective ))
7.420 +thf_quantifier : fol_quantifier (( fol_quantifier ))
7.421 + | CARET (( Lambda ))
7.422 + | DEP_PROD (( Dep_Prod ))
7.423 + | DEP_SUM (( Dep_Sum ))
7.424 + | INDEF_CHOICE (( Epsilon ))
7.425 + | DEFIN_CHOICE (( Iota ))
7.426 +fol_infix_unary : term infix_inequality term (( Pred (infix_inequality, [term1, term2]) ))
7.427 +thf_conn_term : thf_pair_connective (( thf_pair_connective ))
7.428 + | assoc_connective (( assoc_connective ))
7.429 + | thf_unary_connective (( thf_unary_connective ))
7.430 +literal : atomic_formula (( atomic_formula ))
7.431 + | TILDE atomic_formula (( Fmla (Interpreted_Logic Not, [atomic_formula]) ))
7.432 + | fol_infix_unary (( fol_infix_unary ))
7.433 +disjunction : literal (( literal ))
7.434 + | disjunction VLINE literal (( Fmla (Interpreted_Logic Or, [disjunction, literal]) ))
7.435 +cnf_formula : LPAREN disjunction RPAREN (( disjunction ))
7.436 + | disjunction (( disjunction ))
7.437 +fof_tuple_list : fof_logic_formula (( [fof_logic_formula] ))
7.438 + | fof_logic_formula COMMA fof_tuple_list (( fof_logic_formula :: fof_tuple_list ))
7.439 +fof_tuple : LBRKT RBRKT (( [] ))
7.440 + | LBRKT fof_tuple_list RBRKT (( fof_tuple_list ))
7.441 +fof_sequent : fof_tuple GENTZEN_ARROW fof_tuple (( Sequent (fof_tuple1, fof_tuple2) ))
7.442 + | LPAREN fof_sequent RPAREN (( fof_sequent ))
7.443 +unary_connective : TILDE (( Interpreted_Logic Not ))
7.444 +fof_unary_formula : unary_connective fof_unitary_formula (( Fmla (unary_connective, [fof_unitary_formula]) ))
7.445 + | fol_infix_unary (( fol_infix_unary ))
7.446 +fof_variable_list : variable_ (( [variable_] ))
7.447 + | variable_ COMMA fof_variable_list (( variable_ :: fof_variable_list ))
7.448 +fof_quantified_formula : fol_quantifier LBRKT fof_variable_list RBRKT COLON fof_unitary_formula ((
7.449 + Quant (fol_quantifier, map (fn v => (v, NONE)) fof_variable_list, fof_unitary_formula)
7.450 +))
7.451 +fof_unitary_formula : fof_quantified_formula (( fof_quantified_formula ))
7.452 + | fof_unary_formula (( fof_unary_formula ))
7.453 + | atomic_formula (( atomic_formula ))
7.454 + | LPAREN fof_logic_formula RPAREN (( fof_logic_formula ))
7.455 +fof_and_formula : fof_unitary_formula AMPERSAND fof_unitary_formula (( Fmla (Interpreted_Logic And, [fof_unitary_formula1, fof_unitary_formula2]) ))
7.456 + | fof_and_formula AMPERSAND fof_unitary_formula (( Fmla (Interpreted_Logic And, [fof_and_formula, fof_unitary_formula]) ))
7.457 +fof_or_formula : fof_unitary_formula VLINE fof_unitary_formula (( Fmla (Interpreted_Logic Or, [fof_unitary_formula1, fof_unitary_formula2]) ))
7.458 + | fof_or_formula VLINE fof_unitary_formula (( Fmla (Interpreted_Logic Or, [fof_or_formula, fof_unitary_formula]) ))
7.459 +fof_binary_assoc : fof_or_formula (( fof_or_formula ))
7.460 + | fof_and_formula (( fof_and_formula ))
7.461 +fof_binary_nonassoc : fof_unitary_formula binary_connective fof_unitary_formula ((
7.462 + Fmla (binary_connective, [fof_unitary_formula1, fof_unitary_formula2] )
7.463 +))
7.464 +fof_binary_formula : fof_binary_nonassoc (( fof_binary_nonassoc ))
7.465 + | fof_binary_assoc (( fof_binary_assoc ))
7.466 +fof_logic_formula : fof_binary_formula (( fof_binary_formula ))
7.467 + | fof_unitary_formula (( fof_unitary_formula ))
7.468 +fof_formula : fof_logic_formula (( fof_logic_formula ))
7.469 + | fof_sequent (( fof_sequent ))
7.470 +
7.471 +
7.472 +tff_tuple : LBRKT RBRKT (( [] ))
7.473 + | LBRKT tff_tuple_list RBRKT (( tff_tuple_list ))
7.474 +tff_tuple_list : tff_logic_formula COMMA tff_tuple_list (( tff_logic_formula :: tff_tuple_list ))
7.475 + | tff_logic_formula (( [tff_logic_formula] ))
7.476 +tff_sequent : tff_tuple GENTZEN_ARROW tff_tuple (( Sequent (tff_tuple1, tff_tuple2) ))
7.477 + | LPAREN tff_sequent RPAREN (( tff_sequent ))
7.478 +tff_conditional : ITE_F LPAREN tff_logic_formula COMMA tff_logic_formula COMMA tff_logic_formula RPAREN ((
7.479 + Conditional (tff_logic_formula1, tff_logic_formula2, tff_logic_formula3)
7.480 +))
7.481 +tff_defined_var : variable_ LET tff_logic_formula (( Let_fmla ((variable_, NONE), tff_logic_formula) ))
7.482 + | variable_ LET_TERM term (( Let_term ((variable_, NONE), term) ))
7.483 + | LPAREN tff_defined_var RPAREN (( tff_defined_var ))
7.484 +tff_let_list : tff_defined_var (( [tff_defined_var] ))
7.485 + | tff_defined_var COMMA tff_let_list (( tff_defined_var :: tff_let_list ))
7.486 +tptp_let : LET LBRKT tff_let_list RBRKT COLON tff_unitary_formula ((
7.487 + Let (tff_let_list, tff_unitary_formula)
7.488 +))
7.489 +tff_xprod_type : tff_atomic_type TIMES tff_atomic_type (( Prod_type(tff_atomic_type1, tff_atomic_type2) ))
7.490 + | tff_xprod_type TIMES tff_atomic_type (( Prod_type(tff_xprod_type, tff_atomic_type) ))
7.491 + | LPAREN tff_xprod_type RPAREN (( tff_xprod_type ))
7.492 +tff_mapping_type : tff_unitary_type ARROW tff_atomic_type (( Fn_type(tff_unitary_type, tff_atomic_type) ))
7.493 + | LPAREN tff_mapping_type RPAREN (( tff_mapping_type ))
7.494 +tff_atomic_type : atomic_word (( Atom_type atomic_word ))
7.495 + | defined_type (( Defined_type defined_type ))
7.496 +tff_unitary_type : tff_atomic_type (( tff_atomic_type ))
7.497 + | LPAREN tff_xprod_type RPAREN (( tff_xprod_type ))
7.498 +tff_top_level_type : tff_atomic_type (( tff_atomic_type ))
7.499 + | tff_mapping_type (( tff_mapping_type ))
7.500 +tff_untyped_atom : functor_ (( (functor_, NONE) ))
7.501 + | system_functor (( (system_functor, NONE) ))
7.502 +tff_typed_atom : tff_untyped_atom COLON tff_top_level_type (( (fst tff_untyped_atom, SOME tff_top_level_type) ))
7.503 + | LPAREN tff_typed_atom RPAREN (( tff_typed_atom ))
7.504 +
7.505 +tff_unary_formula : unary_connective tff_unitary_formula (( Fmla (unary_connective, [tff_unitary_formula]) ))
7.506 + | fol_infix_unary (( fol_infix_unary ))
7.507 +tff_typed_variable : variable_ COLON tff_atomic_type (( (variable_, SOME tff_atomic_type) ))
7.508 +tff_variable : tff_typed_variable (( tff_typed_variable ))
7.509 + | variable_ (( (variable_, NONE) ))
7.510 +tff_variable_list : tff_variable (( [tff_variable] ))
7.511 + | tff_variable COMMA tff_variable_list (( tff_variable :: tff_variable_list ))
7.512 +tff_quantified_formula : fol_quantifier LBRKT tff_variable_list RBRKT COLON tff_unitary_formula ((
7.513 + Quant (fol_quantifier, tff_variable_list, tff_unitary_formula)
7.514 +))
7.515 +tff_unitary_formula : tff_quantified_formula (( tff_quantified_formula ))
7.516 + | tff_unary_formula (( tff_unary_formula ))
7.517 + | atomic_formula (( atomic_formula ))
7.518 + | tptp_let (( tptp_let ))
7.519 + | variable_ (( Pred (Uninterpreted variable_, []) ))
7.520 + | tff_conditional (( tff_conditional ))
7.521 + | LPAREN tff_logic_formula RPAREN (( tff_logic_formula ))
7.522 +tff_and_formula : tff_unitary_formula AMPERSAND tff_unitary_formula (( Fmla (Interpreted_Logic And, [tff_unitary_formula1, tff_unitary_formula2]) ))
7.523 + | tff_and_formula AMPERSAND tff_unitary_formula (( Fmla (Interpreted_Logic And, [tff_and_formula, tff_unitary_formula]) ))
7.524 +tff_or_formula : tff_unitary_formula VLINE tff_unitary_formula (( Fmla (Interpreted_Logic Or, [tff_unitary_formula1, tff_unitary_formula2]) ))
7.525 + | tff_or_formula VLINE tff_unitary_formula (( Fmla (Interpreted_Logic Or, [tff_or_formula, tff_unitary_formula]) ))
7.526 +tff_binary_assoc : tff_or_formula (( tff_or_formula ))
7.527 + | tff_and_formula (( tff_and_formula ))
7.528 +tff_binary_nonassoc : tff_unitary_formula binary_connective tff_unitary_formula (( Fmla (binary_connective, [tff_unitary_formula1, tff_unitary_formula2]) ))
7.529 +tff_binary_formula : tff_binary_nonassoc (( tff_binary_nonassoc ))
7.530 + | tff_binary_assoc (( tff_binary_assoc ))
7.531 +tff_logic_formula : tff_binary_formula (( tff_binary_formula ))
7.532 + | tff_unitary_formula (( tff_unitary_formula ))
7.533 +tff_formula : tff_logic_formula (( tff_logic_formula ))
7.534 + | tff_typed_atom (( Atom (TFF_Typed_Atom tff_typed_atom) ))
7.535 + | tff_sequent (( tff_sequent ))
7.536 +
7.537 +thf_tuple : LBRKT RBRKT (( [] ))
7.538 + | LBRKT thf_tuple_list RBRKT (( thf_tuple_list ))
7.539 +thf_tuple_list : thf_logic_formula (( [thf_logic_formula] ))
7.540 + | thf_logic_formula COMMA thf_tuple_list (( thf_logic_formula :: thf_tuple_list ))
7.541 +thf_sequent : thf_tuple GENTZEN_ARROW thf_tuple (( Sequent(thf_tuple1, thf_tuple2) ))
7.542 + | LPAREN thf_sequent RPAREN (( thf_sequent ))
7.543 +thf_conditional : ITE_F LPAREN thf_logic_formula COMMA thf_logic_formula COMMA thf_logic_formula RPAREN ((
7.544 + Conditional (thf_logic_formula1, thf_logic_formula2, thf_logic_formula3)
7.545 +))
7.546 +thf_defined_var : thf_variable LET thf_logic_formula (( Let_fmla (thf_variable, thf_logic_formula) ))
7.547 + | LPAREN thf_defined_var RPAREN (( thf_defined_var ))
7.548 +thf_let_list : thf_defined_var (( [thf_defined_var] ))
7.549 + | thf_defined_var COMMA thf_let_list (( thf_defined_var :: thf_let_list ))
7.550 +thf_let : LET LBRKT thf_let_list RBRKT COLON thf_unitary_formula ((
7.551 + Let (thf_let_list, thf_unitary_formula)
7.552 +))
7.553 +thf_atom : term (( Atom (THF_Atom_term term) ))
7.554 + | thf_conn_term (( Atom (THF_Atom_conn_term thf_conn_term) ))
7.555 +thf_union_type : thf_unitary_type PLUS thf_unitary_type (( Sum_type(thf_unitary_type1, thf_unitary_type2) ))
7.556 + | thf_union_type PLUS thf_unitary_type (( Sum_type(thf_union_type, thf_unitary_type) ))
7.557 +thf_xprod_type : thf_unitary_type TIMES thf_unitary_type (( Prod_type(thf_unitary_type1, thf_unitary_type2) ))
7.558 + | thf_xprod_type TIMES thf_unitary_type (( Prod_type(thf_xprod_type, thf_unitary_type) ))
7.559 +thf_mapping_type : thf_unitary_type ARROW thf_unitary_type (( Fn_type(thf_unitary_type1, thf_unitary_type2) ))
7.560 + | thf_unitary_type ARROW thf_mapping_type (( Fn_type(thf_unitary_type, thf_mapping_type) ))
7.561 +thf_binary_type : thf_mapping_type (( thf_mapping_type ))
7.562 + | thf_xprod_type (( thf_xprod_type ))
7.563 + | thf_union_type (( thf_union_type ))
7.564 +thf_unitary_type : thf_unitary_formula (( Fmla_type thf_unitary_formula ))
7.565 +thf_top_level_type : thf_logic_formula (( Fmla_type thf_logic_formula ))
7.566 +thf_subtype : constant SUBTYPE constant (( Subtype(constant1, constant2) ))
7.567 +thf_typeable_formula : thf_atom (( thf_atom ))
7.568 + | LPAREN thf_logic_formula RPAREN (( thf_logic_formula ))
7.569 +thf_type_formula : thf_typeable_formula COLON thf_top_level_type (( (thf_typeable_formula, thf_top_level_type) ))
7.570 +thf_unary_formula : thf_unary_connective LPAREN thf_logic_formula RPAREN ((
7.571 + Fmla (thf_unary_connective, [thf_logic_formula])
7.572 +))
7.573 +thf_typed_variable : variable_ COLON thf_top_level_type (( (variable_, SOME thf_top_level_type) ))
7.574 +thf_variable : thf_typed_variable (( thf_typed_variable ))
7.575 + | variable_ (( (variable_, NONE) ))
7.576 +thf_variable_list : thf_variable (( [thf_variable] ))
7.577 + | thf_variable COMMA thf_variable_list (( thf_variable :: thf_variable_list ))
7.578 +thf_quantified_formula : thf_quantifier LBRKT thf_variable_list RBRKT COLON thf_unitary_formula ((
7.579 + Quant (thf_quantifier, thf_variable_list, thf_unitary_formula)
7.580 +))
7.581 +thf_unitary_formula : thf_quantified_formula (( thf_quantified_formula ))
7.582 + | thf_unary_formula (( thf_unary_formula ))
7.583 + | thf_atom (( thf_atom ))
7.584 + | thf_let (( thf_let ))
7.585 + | thf_conditional (( thf_conditional ))
7.586 + | LPAREN thf_logic_formula RPAREN (( thf_logic_formula ))
7.587 +thf_apply_formula : thf_unitary_formula AT_SIGN thf_unitary_formula (( Fmla (Interpreted_ExtraLogic Apply, [thf_unitary_formula1, thf_unitary_formula2]) ))
7.588 + | thf_apply_formula AT_SIGN thf_unitary_formula (( Fmla (Interpreted_ExtraLogic Apply, [thf_apply_formula, thf_unitary_formula]) ))
7.589 +thf_and_formula : thf_unitary_formula AMPERSAND thf_unitary_formula (( Fmla (Interpreted_Logic And, [thf_unitary_formula1, thf_unitary_formula2]) ))
7.590 + | thf_and_formula AMPERSAND thf_unitary_formula (( Fmla (Interpreted_Logic And, [thf_and_formula, thf_unitary_formula]) ))
7.591 +thf_or_formula : thf_unitary_formula VLINE thf_unitary_formula (( Fmla (Interpreted_Logic Or, [thf_unitary_formula1, thf_unitary_formula2]) ))
7.592 + | thf_or_formula VLINE thf_unitary_formula (( Fmla (Interpreted_Logic Or, [thf_or_formula, thf_unitary_formula]) ))
7.593 +thf_binary_tuple : thf_or_formula (( thf_or_formula ))
7.594 + | thf_and_formula (( thf_and_formula ))
7.595 + | thf_apply_formula (( thf_apply_formula ))
7.596 +thf_binary_pair : thf_unitary_formula thf_pair_connective thf_unitary_formula ((
7.597 + Fmla (thf_pair_connective, [thf_unitary_formula1, thf_unitary_formula2])
7.598 +))
7.599 +thf_binary_formula : thf_binary_pair (( thf_binary_pair ))
7.600 + | thf_binary_tuple (( thf_binary_tuple ))
7.601 + | thf_binary_type (( THF_type thf_binary_type ))
7.602 +thf_logic_formula : thf_binary_formula (( thf_binary_formula ))
7.603 + | thf_unitary_formula (( thf_unitary_formula ))
7.604 + | thf_type_formula (( THF_typing thf_type_formula ))
7.605 + | thf_subtype (( THF_type thf_subtype ))
7.606 +thf_formula : thf_logic_formula (( thf_logic_formula ))
7.607 + | thf_sequent (( thf_sequent ))
7.608 +
7.609 +formula_role : LOWER_WORD (( classify_role LOWER_WORD ))
7.610 +
7.611 +thf_annotated : THF LPAREN name COMMA formula_role COMMA thf_formula annotations RPAREN PERIOD ((
7.612 + Annotated_Formula ((file_name, THFleft + 1, THFright + 1),
7.613 + THF, name, formula_role, thf_formula, annotations)
7.614 +))
7.615 +
7.616 +tff_annotated : TFF LPAREN name COMMA formula_role COMMA tff_formula annotations RPAREN PERIOD ((
7.617 + Annotated_Formula ((file_name, TFFleft + 1, TFFright + 1),
7.618 + TFF, name, formula_role, tff_formula, annotations)
7.619 +))
7.620 +
7.621 +fof_annotated : FOF LPAREN name COMMA formula_role COMMA fof_formula annotations RPAREN PERIOD ((
7.622 + Annotated_Formula ((file_name, FOFleft + 1, FOFright + 1),
7.623 + FOF, name, formula_role, fof_formula, annotations)
7.624 +))
7.625 +
7.626 +cnf_annotated : CNF LPAREN name COMMA formula_role COMMA cnf_formula annotations RPAREN PERIOD ((
7.627 + Annotated_Formula ((file_name, CNFleft + 1, CNFright + 1),
7.628 + CNF, name, formula_role, cnf_formula, annotations)
7.629 +))
7.630 +
7.631 +annotated_formula : cnf_annotated (( cnf_annotated ))
7.632 + | fof_annotated (( fof_annotated ))
7.633 + | tff_annotated (( tff_annotated ))
7.634 + | thf_annotated (( thf_annotated ))
7.635 +
7.636 +include_ : INCLUDE LPAREN file_name formula_selection RPAREN PERIOD ((
7.637 + Include (file_name, formula_selection)
7.638 +))
7.639 +
7.640 +formula_selection : COMMA LBRKT name_list RBRKT (( name_list ))
7.641 + | (( [] ))
7.642 +
7.643 +name_list : name COMMA name_list (( name :: name_list ))
7.644 + | name (( [name] ))
7.645 +
7.646 +name : atomic_word (( atomic_word ))
7.647 + | integer (( integer ))
7.648 +
7.649 +tptp_input : annotated_formula (( annotated_formula ))
7.650 + | include_ (( include_ ))
7.651 +
7.652 +tptp_file : tptp_input tptp_file (( tptp_input :: tptp_file ))
7.653 + | COMMENT tptp_file (( tptp_file ))
7.654 + | (( [] ))
7.655 +
7.656 +tptp : tptp_file (( tptp_file ))
8.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
8.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp_interpret.ML Fri Mar 09 15:38:55 2012 +0000
8.3 @@ -0,0 +1,924 @@
8.4 +(* Title: HOL/TPTP/?/tptp_interpret.ML
8.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
8.6 +
8.7 +Interprets TPTP problems in Isabelle/HOL.
8.8 +*)
8.9 +
8.10 +signature TPTP_INTERPRET =
8.11 +sig
8.12 + (*signature extension: typing information for variables and constants
8.13 + (note that the former isn't really part of the signature, but it's bundled
8.14 + along for more configurability -- though it's probably useless and could be
8.15 + dropped in the future.*)
8.16 + type const_map = (string * term) list
8.17 + type var_types = (string * typ option) list
8.18 +
8.19 + (*mapping from THF types to Isabelle/HOL types. This map works over all
8.20 + base types (i.e. THF functions must be interpreted as Isabelle/HOL functions).
8.21 + The map must be total wrt THF types. Later on there could be a configuration
8.22 + option to make a map extensible.*)
8.23 + type type_map = (TPTP_Syntax.tptp_type * typ) list
8.24 +
8.25 + (*inference info, when available, consists of the name of the inference rule
8.26 + and the names of the inferences involved in the reasoning step.*)
8.27 + type inference_info = (string * string list) option
8.28 +
8.29 + (*a parsed annotated formula is represented as a triple consisting of
8.30 + the formula's label, its role, and a constant function to its Isabelle/HOL
8.31 + term meaning*)
8.32 + type tptp_formula_meaning =
8.33 + string * TPTP_Syntax.role * TPTP_Syntax.tptp_formula * term * inference_info
8.34 +
8.35 + (*In general, the meaning of a TPTP statement (which, through the Include
8.36 + directive, may include the meaning of an entire TPTP file, is an extended
8.37 + Isabelle/HOL theory, an explicit map from constants to their Isabelle/HOL
8.38 + counterparts and their types, the meaning of any TPTP formulas encountered
8.39 + while interpreting that statement, and a map from THF to Isabelle/HOL types
8.40 + (these types would have been added to the theory returned in the first position
8.41 + of the tuple). The last value is NONE when the function which produced the
8.42 + whole tptp_general_meaning value was given a type_map argument -- since
8.43 + this means that the type_map is already known, and it has not been changed.*)
8.44 + type tptp_general_meaning =
8.45 + (type_map * const_map * tptp_formula_meaning list)
8.46 +
8.47 + (*if problem_name is given then it is used to qualify types & constants*)
8.48 + type config =
8.49 + {(*init_type_map : type_map with_origin,
8.50 + init_const_map : type_map with_origin,*)
8.51 + cautious : bool,
8.52 + problem_name : TPTP_Problem_Name.problem_name option
8.53 + (*dont_build_maps : bool,
8.54 + extend_given_type_map : bool,
8.55 + extend_given_const_map : bool,
8.56 + generative_type_interpretation : bool,
8.57 + generative_const_interpretation : bool*)}
8.58 +
8.59 + (*map types form THF to Isabelle/HOL*)
8.60 + val interpret_type : config -> theory -> type_map ->
8.61 + TPTP_Syntax.tptp_type -> typ
8.62 +
8.63 + (*interpret a TPTP line: return an updated theory including the
8.64 + types & constants which were specified in that formula, a map from
8.65 + constant names to their types, and a map from constant names to Isabelle/HOL
8.66 + constants; and a list possible formulas resulting from that line.
8.67 + Note that type/constant declarations do not result in any formulas being
8.68 + returned. A typical TPTP line might update the theory, or return a single
8.69 + formula. The sole exception is the "include" directive which may update the
8.70 + theory and also return a list of formulas from the included file.
8.71 + Arguments:
8.72 + cautious = indicates whether additional checks are made to check
8.73 + that all used types have been declared.
8.74 + type_map = mapping of THF-types to Isabelle/HOL types. This argument may be
8.75 + given to force a specific mapping: this is usually done for using an
8.76 + imported THF problem in Isar.
8.77 + const_map = as previous, but for constants.
8.78 + path_prefix = path where THF problems etc are located (to help the "include"
8.79 + directive find the files.
8.80 + thy = theory where interpreted info will be stored.
8.81 + *)
8.82 +
8.83 + (*map terms form TPTP to Isabelle/HOL*)
8.84 + val interpret_term : bool -> config -> TPTP_Syntax.language -> theory ->
8.85 + const_map -> var_types -> type_map -> TPTP_Syntax.tptp_term ->
8.86 + term * theory
8.87 +
8.88 + val interpret_formula : config -> TPTP_Syntax.language -> const_map ->
8.89 + var_types -> type_map -> TPTP_Syntax.tptp_formula -> theory ->
8.90 + term * theory
8.91 +
8.92 + val interpret_line : config -> type_map -> const_map ->
8.93 + Path.T -> TPTP_Syntax.tptp_line -> theory -> tptp_general_meaning * theory
8.94 +
8.95 + (*Like "interpret_line" above, but works over a whole parsed problem.
8.96 + Arguments:
8.97 + new_basic_types = indicates whether interpretations of $i and $o
8.98 + types are to be added to the type map (unless it is Given).
8.99 + This is "true" if we are running this over a fresh THF problem, but
8.100 + "false" if we are calling this _during_ the interpretation of a THF file
8.101 + (i.e. when interpreting an "include" directive.
8.102 + config = config
8.103 + path_prefix = " "
8.104 + contents = parsed TPTP syntax
8.105 + type_map = see "interpret_line"
8.106 + const_map = " "
8.107 + thy = " "
8.108 + *)
8.109 + val interpret_problem : bool -> config -> Path.T ->
8.110 + TPTP_Syntax.tptp_line list -> type_map -> const_map -> theory ->
8.111 + tptp_general_meaning * theory
8.112 +
8.113 + (*Like "interpret_problem" above, but it's given a filename rather than
8.114 + a parsed problem.*)
8.115 + val interpret_file : bool -> Path.T -> Path.T -> type_map -> const_map ->
8.116 + theory -> tptp_general_meaning * theory
8.117 +
8.118 + (*General exception for this signature.*)
8.119 + exception MISINTERPRET_FORMULA of string * TPTP_Syntax.tptp_formula
8.120 + exception MISINTERPRET_SYMBOL of string * TPTP_Syntax.symbol
8.121 + exception MISINTERPRET_TERM of string * TPTP_Syntax.tptp_term
8.122 + exception MISINTERPRET_TYPE of string * TPTP_Syntax.tptp_type
8.123 +
8.124 + (*Generates a fresh Isabelle/HOL type for interpreting a THF type in a theory.*)
8.125 + val declare_type : config -> (TPTP_Syntax.tptp_type * string) -> type_map ->
8.126 + theory -> type_map * theory
8.127 +
8.128 + (*Returns the list of all files included in a directory and its
8.129 + subdirectories. This is only used for testing the parser/interpreter against
8.130 + all THF problems.*)
8.131 + val get_file_list : Path.T -> Path.T list
8.132 +
8.133 + type manifest = TPTP_Problem_Name.problem_name * tptp_general_meaning
8.134 +
8.135 + val get_manifests : theory -> manifest list
8.136 +
8.137 + val import_file : bool -> Path.T -> Path.T -> type_map -> const_map ->
8.138 + theory -> theory
8.139 +
8.140 + val extract_inference_info : (TPTP_Syntax.general_term * 'a list) option ->
8.141 + (string * string list) option
8.142 +end
8.143 +
8.144 +structure TPTP_Interpret : TPTP_INTERPRET =
8.145 +struct
8.146 +
8.147 +open TPTP_Syntax
8.148 +exception MISINTERPRET_FORMULA of string * TPTP_Syntax.tptp_formula
8.149 +exception MISINTERPRET_SYMBOL of string * TPTP_Syntax.symbol
8.150 +exception MISINTERPRET_TERM of string * TPTP_Syntax.tptp_term
8.151 +exception MISINTERPRET_TYPE of string * TPTP_Syntax.tptp_type
8.152 +
8.153 +(* General stuff *)
8.154 +
8.155 +type config =
8.156 + {(*init_type_map : type_map with_origin,
8.157 + init_const_map : type_map with_origin,*)
8.158 + cautious : bool,
8.159 + problem_name : TPTP_Problem_Name.problem_name option
8.160 + (*dont_build_maps : bool,
8.161 + extend_given_type_map : bool,
8.162 + extend_given_const_map : bool,
8.163 + generative_type_interpretation : bool,
8.164 + generative_const_interpretation : bool*)}
8.165 +
8.166 +(* Interpretation *)
8.167 +
8.168 +(** Signatures and other type abbrevations **)
8.169 +
8.170 +type const_map = (string * term) list
8.171 +type var_types = (string * typ option) list
8.172 +type type_map = (TPTP_Syntax.tptp_type * typ) list
8.173 +type inference_info = (string * string list) option
8.174 +type tptp_formula_meaning =
8.175 + string * TPTP_Syntax.role * TPTP_Syntax.tptp_formula * term * inference_info
8.176 +type tptp_general_meaning =
8.177 + (type_map * const_map * tptp_formula_meaning list)
8.178 +
8.179 +type manifest = TPTP_Problem_Name.problem_name * tptp_general_meaning
8.180 +structure TPTP_Data = Theory_Data
8.181 + (type T = manifest list
8.182 + val empty = []
8.183 + val extend = I
8.184 + val merge = Library.merge (op =))
8.185 +val get_manifests = TPTP_Data.get
8.186 +
8.187 +
8.188 +(** Adding types to a signature **)
8.189 +
8.190 +fun type_exists thy ty_name =
8.191 + Sign.declared_tyname thy (Sign.full_bname thy ty_name)
8.192 +
8.193 +val IND_TYPE = "ind"
8.194 +
8.195 +fun mk_binding config ident =
8.196 + let
8.197 + val pre_binding = Binding.name ident
8.198 + in
8.199 + case #problem_name config of
8.200 + NONE => pre_binding
8.201 + | SOME prob =>
8.202 + Binding.qualify
8.203 + false
8.204 + (TPTP_Problem_Name.mangle_problem_name prob)
8.205 + pre_binding
8.206 + end
8.207 +
8.208 +(*Returns updated theory and the name of the final type's name -- i.e. if the
8.209 +original name is already taken then the function looks for an available
8.210 +alternative. It also returns an updated type_map if one has been passed to it.*)
8.211 +fun declare_type (config : config) (thf_type, type_name) ty_map thy =
8.212 + if type_exists thy type_name then
8.213 + raise MISINTERPRET_TYPE ("Type already exists", Atom_type type_name)
8.214 + else
8.215 + let
8.216 + val binding = mk_binding config type_name
8.217 + val final_fqn = Sign.full_name thy binding
8.218 + val thy' = Typedecl.typedecl_global (mk_binding config type_name, [], NoSyn) thy |> snd
8.219 + val typ_map_entry = (thf_type, (Type (final_fqn, [])))
8.220 + val ty_map' = typ_map_entry :: ty_map
8.221 + in (ty_map', thy') end
8.222 +
8.223 +
8.224 +(** Adding constants to signature **)
8.225 +
8.226 +fun full_name thy config const_name =
8.227 + Sign.full_name thy (mk_binding config const_name)
8.228 +
8.229 +fun const_exists config thy const_name =
8.230 + Sign.declared_const thy (full_name thy config const_name)
8.231 +
8.232 +fun declare_constant config const_name ty thy =
8.233 + if const_exists config thy const_name then
8.234 + raise MISINTERPRET_TERM
8.235 + ("Const already declared", Term_Func (Uninterpreted const_name, []))
8.236 + else
8.237 + Theory.specify_const
8.238 + ((mk_binding config const_name, ty), NoSyn) thy
8.239 +
8.240 +
8.241 +(** Interpretation **)
8.242 +
8.243 +(*Types in THF are encoded as formulas. This function translates them to type form.*)
8.244 +(*FIXME possibly incomplete hack*)
8.245 +fun fmlatype_to_type (Atom (THF_Atom_term (Term_Func (TypeSymbol typ, [])))) =
8.246 + Defined_type typ
8.247 + | fmlatype_to_type (Atom (THF_Atom_term (Term_Func (Uninterpreted str, [])))) =
8.248 + Atom_type str
8.249 + | fmlatype_to_type (THF_type (Fn_type (ty1, ty2))) =
8.250 + let
8.251 + val ty1' = case ty1 of
8.252 + Fn_type _ => fmlatype_to_type (THF_type ty1)
8.253 + | Fmla_type ty1 => fmlatype_to_type ty1
8.254 + val ty2' = case ty2 of
8.255 + Fn_type _ => fmlatype_to_type (THF_type ty2)
8.256 + | Fmla_type ty2 => fmlatype_to_type ty2
8.257 + in Fn_type (ty1', ty2') end
8.258 +
8.259 +fun interpret_type config thy type_map thf_ty =
8.260 + let
8.261 + fun lookup_type ty_map thf_ty =
8.262 + (case AList.lookup (op =) ty_map thf_ty of
8.263 + NONE =>
8.264 + raise MISINTERPRET_TYPE
8.265 + ("Could not find the interpretation of this TPTP type in the " ^
8.266 + "mapping to Isabelle/HOL", thf_ty)
8.267 + | SOME ty => ty)
8.268 + in
8.269 + case thf_ty of (*FIXME make tail*)
8.270 + Prod_type (thf_ty1, thf_ty2) =>
8.271 + Type ("Product_Type.prod",
8.272 + [interpret_type config thy type_map thf_ty1,
8.273 + interpret_type config thy type_map thf_ty2])
8.274 + | Fn_type (thf_ty1, thf_ty2) =>
8.275 + Type ("fun",
8.276 + [interpret_type config thy type_map thf_ty1,
8.277 + interpret_type config thy type_map thf_ty2])
8.278 + | Atom_type _ =>
8.279 + lookup_type type_map thf_ty
8.280 + | Defined_type tptp_base_type =>
8.281 + (case tptp_base_type of
8.282 + Type_Ind =>
8.283 + lookup_type type_map thf_ty
8.284 + | Type_Bool => HOLogic.boolT
8.285 + | Type_Type =>
8.286 + raise MISINTERPRET_TYPE
8.287 + ("No type interpretation", thf_ty)
8.288 + | Type_Int => Type ("Int.int", [])
8.289 + (*FIXME these types are currently unsupported, so they're treated as
8.290 + individuals*)
8.291 + | Type_Rat =>
8.292 + interpret_type config thy type_map (Defined_type Type_Ind)
8.293 + | Type_Real =>
8.294 + interpret_type config thy type_map (Defined_type Type_Ind)
8.295 + )
8.296 + | Sum_type _ =>
8.297 + raise MISINTERPRET_TYPE (*FIXME*)
8.298 + ("No type interpretation (sum type)", thf_ty)
8.299 + | Fmla_type tptp_ty =>
8.300 + fmlatype_to_type tptp_ty
8.301 + |> interpret_type config thy type_map
8.302 + | Subtype _ =>
8.303 + raise MISINTERPRET_TYPE (*FIXME*)
8.304 + ("No type interpretation (subtype)", thf_ty)
8.305 + end
8.306 +
8.307 +fun the_const config thy language const_map_payload str =
8.308 + if language = THF then
8.309 + (case AList.lookup (op =) const_map_payload str of
8.310 + NONE => raise MISINTERPRET_TERM
8.311 + ("Could not find the interpretation of this constant in the " ^
8.312 + "mapping to Isabelle/HOL", Term_Func (Uninterpreted str, []))
8.313 + | SOME t => t)
8.314 + else
8.315 + if const_exists config thy str then
8.316 + Sign.mk_const thy ((Sign.full_name thy (mk_binding config str)), [])
8.317 + else raise MISINTERPRET_TERM
8.318 + ("Could not find the interpretation of this constant in the " ^
8.319 + "mapping to Isabelle/HOL: ", Term_Func (Uninterpreted str, []))
8.320 +
8.321 +(*Eta-expands Isabelle/HOL binary function.
8.322 + "str" is the name of a polymorphic constant in Isabelle/HOL*)
8.323 +fun mk_fun str =
8.324 + (Const (str, Term.dummyT) $ Bound 1 $ Bound 0)
8.325 + |> (Term.absdummy Term.dummyT #> Term.absdummy Term.dummyT)
8.326 +(*As above, but swaps the function's arguments*)
8.327 +fun mk_swapped_fun str =
8.328 + (Const (str, Term.dummyT) $ Bound 0 $ Bound 1)
8.329 + |> (Term.absdummy Term.dummyT #> Term.absdummy Term.dummyT)
8.330 +
8.331 +fun dummy_THF () =
8.332 + HOLogic.choice_const Term.dummyT $ Term.absdummy Term.dummyT @{term "True"}
8.333 +
8.334 +fun interpret_symbol config thy language const_map symb =
8.335 + case symb of
8.336 + Uninterpreted n =>
8.337 + (*Constant would have been added to the map at the time of
8.338 + declaration*)
8.339 + the_const config thy language const_map n
8.340 + | Interpreted_ExtraLogic interpreted_symbol =>
8.341 + (case interpreted_symbol of (*FIXME incomplete,
8.342 + and doesn't work with $i*)
8.343 + Sum => mk_fun @{const_name Groups.plus}
8.344 + | UMinus =>
8.345 + (Const (@{const_name Groups.uminus}, Term.dummyT) $ Bound 0)
8.346 + |> Term.absdummy Term.dummyT
8.347 + | Difference => mk_fun @{const_name Groups.minus}
8.348 + | Product => mk_fun @{const_name Groups.times}
8.349 + | Quotient => mk_fun @{const_name Fields.divide}
8.350 + | Less => mk_fun @{const_name Orderings.less}
8.351 + | LessEq => mk_fun @{const_name Orderings.less_eq}
8.352 + | Greater => mk_swapped_fun @{const_name Orderings.less}
8.353 + (*FIXME would be nicer to expand "greater"
8.354 + and "greater_eq" abbreviations*)
8.355 + | GreaterEq => mk_swapped_fun @{const_name Orderings.less_eq}
8.356 + (* FIXME todo
8.357 + | Quotient_E | Quotient_T | Quotient_F | Remainder_E | Remainder_T
8.358 + | Remainder_F | Floor | Ceiling | Truncate | Round | To_Int | To_Rat
8.359 + | To_Real | EvalEq | Is_Int | Is_Rat*)
8.360 + | Apply => raise MISINTERPRET_SYMBOL ("Malformed term?", symb)
8.361 + | _ => dummy_THF ()
8.362 + )
8.363 + | Interpreted_Logic logic_symbol =>
8.364 + (case logic_symbol of
8.365 + Equals => HOLogic.eq_const Term.dummyT
8.366 + | NEquals =>
8.367 + HOLogic.mk_not (HOLogic.eq_const Term.dummyT $ Bound 1 $ Bound 0)
8.368 + |> (Term.absdummy Term.dummyT #> Term.absdummy Term.dummyT)
8.369 + | Or => HOLogic.disj
8.370 + | And => HOLogic.conj
8.371 + | Iff => HOLogic.eq_const HOLogic.boolT
8.372 + | If => HOLogic.imp
8.373 + | Fi => @{term "\<lambda> x. \<lambda> y. y \<longrightarrow> x"}
8.374 + | Xor =>
8.375 + @{term
8.376 + "\<lambda> x. \<lambda> y. \<not> (x \<longleftrightarrow> y)"}
8.377 + | Nor => @{term "\<lambda> x. \<lambda> y. \<not> (x \<or> y)"}
8.378 + | Nand => @{term "\<lambda> x. \<lambda> y. \<not> (x \<and> y)"}
8.379 + | Not => HOLogic.Not
8.380 + | Op_Forall => HOLogic.all_const Term.dummyT
8.381 + | Op_Exists => HOLogic.exists_const Term.dummyT
8.382 + | True => @{term "True"}
8.383 + | False => @{term "False"}
8.384 + )
8.385 + | TypeSymbol _ =>
8.386 + raise MISINTERPRET_SYMBOL
8.387 + ("Cannot have TypeSymbol in term", symb)
8.388 + | System str =>
8.389 + raise MISINTERPRET_SYMBOL
8.390 + ("How to interpret system terms?", symb)
8.391 +
8.392 +(*Apply a function to a list of arguments*)
8.393 +val mapply = fold (fn x => fn y => y $ x)
8.394 +(*As above, but for products*)
8.395 +fun mtimes thy =
8.396 + fold (fn x => fn y =>
8.397 + Sign.mk_const thy
8.398 + ("Product_Type.Pair",[Term.dummyT, Term.dummyT]) $ y $ x)
8.399 +
8.400 +(*Adds constants to signature in FOL. "formula_level" means that the constants
8.401 +are to be interpreted as predicates, otherwise as functions over individuals.*)
8.402 +fun FO_const_types config formula_level type_map tptp_t thy =
8.403 + let
8.404 + val ind_type = interpret_type config thy type_map (Defined_type Type_Ind)
8.405 + val value_type =
8.406 + if formula_level then
8.407 + interpret_type config thy type_map (Defined_type Type_Bool)
8.408 + else ind_type
8.409 + in case tptp_t of
8.410 + Term_Func (symb, tptp_ts) =>
8.411 + let
8.412 + val thy' = fold (FO_const_types config false type_map) tptp_ts thy
8.413 + val ty = fold (fn ty1 => fn ty2 => Type ("fun", [ty1, ty2]))
8.414 + (map (fn _ => ind_type) tptp_ts) value_type
8.415 + in
8.416 + case symb of
8.417 + Uninterpreted const_name =>
8.418 + if const_exists config thy' const_name then thy'
8.419 + else snd (declare_constant config const_name ty thy')
8.420 + | _ => thy'
8.421 + end
8.422 + | _ => thy
8.423 + end
8.424 +
8.425 +(*like FO_const_types but works over symbols*)
8.426 +fun symb_const_types config type_map formula_level const_name n_args thy =
8.427 + let
8.428 + val ind_type = interpret_type config thy type_map (Defined_type Type_Ind)
8.429 + val value_type =
8.430 + if formula_level then
8.431 + interpret_type config thy type_map (Defined_type Type_Bool)
8.432 + else interpret_type config thy type_map (Defined_type Type_Ind)
8.433 + fun mk_i_fun b n acc =
8.434 + if n = 0 then acc b
8.435 + else
8.436 + mk_i_fun b (n - 1) (fn ty => Type ("fun", [ind_type, acc ty]))
8.437 + in
8.438 + if const_exists config thy const_name then thy
8.439 + else
8.440 + snd (declare_constant config const_name
8.441 + (mk_i_fun value_type n_args I) thy)
8.442 + end
8.443 +
8.444 +(*Next batch of functions give info about Isabelle/HOL types*)
8.445 +fun is_fun (Type ("fun", _)) = true
8.446 + | is_fun _ = false
8.447 +fun is_prod (Type ("Product_Type.prod", _)) = true
8.448 + | is_prod _ = false
8.449 +fun dom_type (Type ("fun", [ty1, _])) = ty1
8.450 +fun is_prod_typed thy config symb =
8.451 + let
8.452 + fun symb_type const_name =
8.453 + Sign.the_const_type thy (full_name thy config const_name)
8.454 + in
8.455 + case symb of
8.456 + Uninterpreted const_name =>
8.457 + if is_fun (symb_type const_name) then
8.458 + symb_type const_name |> dom_type |> is_prod
8.459 + else false
8.460 + | _ => false
8.461 + end
8.462 +
8.463 +
8.464 +(*
8.465 + Information needed to be carried around:
8.466 + - constant mapping: maps constant names to Isabelle terms with fully-qualified
8.467 + names. This is fixed, and it is determined by declaration lines earlier
8.468 + in the script (i.e. constants must be declared before appearing in terms.
8.469 + - type context: maps bound variables to their Isabelle type. This is discarded
8.470 + after each call of interpret_term since variables' can't be bound across
8.471 + terms.
8.472 +*)
8.473 +fun interpret_term formula_level config language thy const_map var_types type_map tptp_t =
8.474 + case tptp_t of
8.475 + Term_Func (symb, tptp_ts) =>
8.476 + let
8.477 + val thy' = FO_const_types config formula_level type_map tptp_t thy
8.478 + fun typeof_const const_name = Sign.the_const_type thy'
8.479 + (Sign.full_name thy' (mk_binding config const_name))
8.480 + in
8.481 + case symb of
8.482 + Interpreted_ExtraLogic Apply =>
8.483 + (*apply the head of the argument list to the tail*)
8.484 + (mapply
8.485 + (map (interpret_term false config language thy' const_map
8.486 + var_types type_map #> fst) (tl tptp_ts))
8.487 + (interpret_term formula_level config language thy' const_map
8.488 + var_types type_map (hd tptp_ts) |> fst),
8.489 + thy')
8.490 + | _ =>
8.491 + (*apply symb to tptp_ts*)
8.492 + if is_prod_typed thy' config symb then
8.493 + (interpret_symbol config thy' language const_map symb $
8.494 + mtimes thy'
8.495 + (map (interpret_term false config language thy' const_map
8.496 + var_types type_map #> fst) (tl tptp_ts))
8.497 + ((interpret_term false config language thy' const_map
8.498 + var_types type_map #> fst) (hd tptp_ts)),
8.499 + thy')
8.500 + else
8.501 + (mapply
8.502 + (map (interpret_term false config language thy' const_map
8.503 + var_types type_map #> fst) tptp_ts)
8.504 + (interpret_symbol config thy' language const_map symb),
8.505 + thy')
8.506 + end
8.507 + | Term_Var n =>
8.508 + (if language = THF orelse language = TFF then
8.509 + (case AList.lookup (op =) var_types n of
8.510 + SOME ty =>
8.511 + (case ty of
8.512 + SOME ty => Free (n, ty)
8.513 + | NONE => Free (n, Term.dummyT) (*to infer the variable's type*)
8.514 + )
8.515 + | NONE =>
8.516 + raise MISINTERPRET_TERM ("Could not type variable", tptp_t))
8.517 + else (*variables range over individuals*)
8.518 + Free (n, interpret_type config thy type_map (Defined_type Type_Ind)),
8.519 + thy)
8.520 + | Term_Conditional (tptp_formula, tptp_t1, tptp_t2) =>
8.521 + (mk_fun @{const_name If}, thy)
8.522 + | Term_Num (number_kind, num) =>
8.523 + let
8.524 + val num_term =
8.525 + if number_kind = Int_num then
8.526 + HOLogic.mk_number @{typ "int"} (the (Int.fromString num))
8.527 + else dummy_THF () (*FIXME: not yet supporting rationals and reals*)
8.528 + in (num_term, thy) end
8.529 + | Term_Distinct_Object str =>
8.530 + let
8.531 + fun alphanumerate c =
8.532 + let
8.533 + val c' = ord c
8.534 + val out_of_range =
8.535 + ((c' > 64) andalso (c' < 91)) orelse ((c' > 96)
8.536 + andalso (c' < 123)) orelse ((c' > 47) andalso (c' < 58))
8.537 + in
8.538 + if (not out_of_range) andalso (not (c = "_")) then
8.539 + "_nom_" ^ Int.toString (ord c) ^ "_"
8.540 + else c
8.541 + end
8.542 + val mangle_name = raw_explode #> map alphanumerate #> implode
8.543 + in declare_constant config (mangle_name str)
8.544 + (interpret_type config thy type_map (Defined_type Type_Ind)) thy
8.545 + end
8.546 +
8.547 +(*Given a list of "'a option", then applies a function to each element if that
8.548 +element is SOME value, otherwise it leaves it as NONE.*)
8.549 +fun map_opt f xs =
8.550 + fold
8.551 + (fn x => fn y =>
8.552 + (if Option.isSome x then
8.553 + SOME (f (Option.valOf x))
8.554 + else NONE) :: y
8.555 + ) xs []
8.556 +
8.557 +fun interpret_formula config language const_map var_types type_map tptp_fmla thy =
8.558 + case tptp_fmla of
8.559 + Pred app =>
8.560 + interpret_term true config language thy const_map
8.561 + var_types type_map (Term_Func app)
8.562 + | Fmla (symbol, tptp_formulas) =>
8.563 + (case symbol of
8.564 + Interpreted_ExtraLogic Apply =>
8.565 + let
8.566 + val (args, thy') = (fold_map (interpret_formula config language
8.567 + const_map var_types type_map) (tl tptp_formulas) thy)
8.568 + val (func, thy') = interpret_formula config language const_map
8.569 + var_types type_map (hd tptp_formulas) thy'
8.570 + in (mapply args func, thy') end
8.571 + | Uninterpreted const_name =>
8.572 + let
8.573 + val (args, thy') = (fold_map (interpret_formula config language
8.574 + const_map var_types type_map) tptp_formulas thy)
8.575 + val thy' = symb_const_types config type_map true const_name
8.576 + (length tptp_formulas) thy'
8.577 + in
8.578 + (if is_prod_typed thy' config symbol then
8.579 + mtimes thy' args (interpret_symbol config thy' language
8.580 + const_map symbol)
8.581 + else
8.582 + mapply args
8.583 + (interpret_symbol config thy' language const_map symbol),
8.584 + thy')
8.585 + end
8.586 + | _ =>
8.587 + let
8.588 + val (args, thy') =
8.589 + fold_map
8.590 + (interpret_formula config language
8.591 + const_map var_types type_map)
8.592 + tptp_formulas thy
8.593 + in
8.594 + (if is_prod_typed thy' config symbol then
8.595 + mtimes thy' args (interpret_symbol config thy' language
8.596 + const_map symbol)
8.597 + else
8.598 + mapply args
8.599 + (interpret_symbol config thy' language const_map symbol),
8.600 + thy')
8.601 + end)
8.602 + | Sequent _ =>
8.603 + raise MISINTERPRET_FORMULA ("Sequent", tptp_fmla) (*FIXME unsupported*)
8.604 + | Quant (quantifier, bindings, tptp_formula) =>
8.605 + let
8.606 + val (bound_vars, bound_var_types) = ListPair.unzip bindings
8.607 + val bound_var_types' : typ option list =
8.608 + (map_opt : (tptp_type -> typ) -> (tptp_type option list) -> typ option list)
8.609 + (interpret_type config thy type_map) bound_var_types
8.610 + val var_types' =
8.611 + ListPair.zip (bound_vars, List.rev bound_var_types')
8.612 + |> List.rev
8.613 + fun fold_bind f =
8.614 + fold
8.615 + (fn (n, ty) => fn t =>
8.616 + case ty of
8.617 + NONE =>
8.618 + f (n,
8.619 + if language = THF then Term.dummyT
8.620 + else
8.621 + interpret_type config thy type_map
8.622 + (Defined_type Type_Ind),
8.623 + t)
8.624 + | SOME ty => f (n, ty, t)
8.625 + )
8.626 + var_types'
8.627 + in case quantifier of
8.628 + Forall =>
8.629 + interpret_formula config language const_map (var_types' @ var_types)
8.630 + type_map tptp_formula thy
8.631 + |>> fold_bind HOLogic.mk_all
8.632 + | Exists =>
8.633 + interpret_formula config language const_map (var_types' @ var_types)
8.634 + type_map tptp_formula thy
8.635 + |>> fold_bind HOLogic.mk_exists
8.636 + | Lambda =>
8.637 + interpret_formula config language const_map (var_types' @ var_types)
8.638 + type_map tptp_formula thy
8.639 + |>> fold_bind (fn (n, ty, rest) => lambda (Free (n, ty)) rest)
8.640 + | Epsilon =>
8.641 + let val (t, thy') =
8.642 + interpret_formula config language const_map var_types type_map
8.643 + (Quant (Lambda, bindings, tptp_formula)) thy
8.644 + in ((HOLogic.choice_const Term.dummyT) $ t, thy') end
8.645 + | Iota =>
8.646 + let val (t, thy') =
8.647 + interpret_formula config language const_map var_types type_map
8.648 + (Quant (Lambda, bindings, tptp_formula)) thy
8.649 + in (Const (@{const_name The}, Term.dummyT) $ t, thy') end
8.650 + | Dep_Prod =>
8.651 + raise MISINTERPRET_FORMULA ("Unsupported", tptp_fmla)
8.652 + | Dep_Sum =>
8.653 + raise MISINTERPRET_FORMULA ("Unsupported", tptp_fmla)
8.654 + end
8.655 + (*FIXME unsupported
8.656 + | Conditional of tptp_formula * tptp_formula * tptp_formula
8.657 + | Let of tptp_let list * tptp_formula
8.658 +
8.659 + and tptp_let =
8.660 + Let_fmla of (string * tptp_type option) * tptp_formula (*both TFF and THF*)
8.661 + | Let_term of (string * tptp_type option) * tptp_term (*only TFF*)
8.662 + *)
8.663 + | Atom tptp_atom =>
8.664 + (case tptp_atom of
8.665 + TFF_Typed_Atom (symbol, tptp_type_opt) =>
8.666 + (*FIXME ignoring type info*)
8.667 + (interpret_symbol config thy language const_map symbol, thy)
8.668 + | THF_Atom_term tptp_term =>
8.669 + interpret_term true config language thy const_map var_types
8.670 + type_map tptp_term
8.671 + | THF_Atom_conn_term symbol =>
8.672 + (interpret_symbol config thy language const_map symbol, thy))
8.673 + | THF_type _ => (*FIXME unsupported*)
8.674 + raise MISINTERPRET_FORMULA
8.675 + ("Cannot interpret types as formulas", tptp_fmla)
8.676 + | THF_typing (tptp_formula, _) => (*FIXME ignoring type info*)
8.677 + interpret_formula config language
8.678 + const_map var_types type_map tptp_formula thy
8.679 +
8.680 +
8.681 +(*Extract name of inference rule, and the inferences it relies on*)
8.682 +(*This is tuned to work with LEO-II, and is brittle to upstream
8.683 + changes of the proof protocol.*)
8.684 +fun extract_inference_info annot =
8.685 + let
8.686 + fun get_line_id (General_Data (Number (Int_num, num))) = [num]
8.687 + | get_line_id (General_Data (Atomic_Word name)) = [name]
8.688 + | get_line_id (General_Term (Number (Int_num, num), _ (*e.g. a bind*))) = [num]
8.689 + | get_line_id _ = []
8.690 + (*e.g. General_Data (Application ("theory", [General_Data
8.691 + (Atomic_Word "equality")])) -- which would come from E through LEO-II*)
8.692 + in
8.693 + case annot of
8.694 + NONE => NONE
8.695 + | SOME annot =>
8.696 + (case annot of
8.697 + (General_Data (Application ("inference",
8.698 + [General_Data (Atomic_Word inference_name),
8.699 + _,
8.700 + General_List related_lines])), _) =>
8.701 + (SOME (inference_name, map get_line_id related_lines |> List.concat))
8.702 + | _ => NONE)
8.703 + end
8.704 +
8.705 +
8.706 +(*Extract the type from a typing*)
8.707 +local
8.708 + fun extract_type tptp_type =
8.709 + case tptp_type of
8.710 + Fmla_type typ => fmlatype_to_type typ
8.711 + | _ => tptp_type
8.712 +in
8.713 + fun typeof_typing (THF_typing (_, tptp_type)) = extract_type tptp_type
8.714 + fun typeof_tff_typing (Atom (TFF_Typed_Atom (_, SOME tptp_type))) =
8.715 + extract_type tptp_type
8.716 +end
8.717 +fun nameof_typing
8.718 + (THF_typing
8.719 + ((Atom (THF_Atom_term (Term_Func (Uninterpreted str, [])))), _)) = str
8.720 +fun nameof_tff_typing (Atom (TFF_Typed_Atom (Uninterpreted str, _))) = str
8.721 +
8.722 +fun interpret_line config type_map const_map path_prefix line thy =
8.723 + case line of
8.724 + Include (quoted_path, _) => (*FIXME currently everything is imported*)
8.725 + interpret_file'
8.726 + false
8.727 + config
8.728 + path_prefix
8.729 + (Path.append
8.730 + path_prefix
8.731 + (quoted_path
8.732 + |> unenclose
8.733 + |> Path.explode))
8.734 + type_map
8.735 + const_map
8.736 + thy
8.737 + | Annotated_Formula (pos, lang, label, role, tptp_formula, annotation_opt) =>
8.738 + case role of
8.739 + Role_Type =>
8.740 + let
8.741 + val thy_name = Context.theory_name thy
8.742 + val (tptp_ty, name) =
8.743 + if lang = THF then
8.744 + (typeof_typing tptp_formula (*assuming tptp_formula is a typing*),
8.745 + nameof_typing tptp_formula (*and that the LHS is a (atom) name*))
8.746 + else
8.747 + (typeof_tff_typing tptp_formula,
8.748 + nameof_tff_typing tptp_formula)
8.749 + in
8.750 + case tptp_ty of
8.751 + Defined_type Type_Type => (*add new type*)
8.752 + (*generate an Isabelle/HOL type to interpret this THF type,
8.753 + and add it to both the Isabelle/HOL theory and to the type_map*)
8.754 + let
8.755 + val (type_map', thy') =
8.756 + declare_type
8.757 + config
8.758 + (Atom_type name, name)
8.759 + type_map
8.760 + thy
8.761 + in ((type_map',
8.762 + const_map,
8.763 + []),
8.764 + thy')
8.765 + end
8.766 +
8.767 + | _ => (*declaration of constant*)
8.768 + (*Here we populate the map from constants to the Isabelle/HOL
8.769 + terms they map to (which in turn contain their types).*)
8.770 + let
8.771 + val ty = interpret_type config thy type_map tptp_ty
8.772 + (*make sure that the theory contains all the types appearing
8.773 + in this constant's signature. Exception is thrown if encounter
8.774 + an undeclared types.*)
8.775 + val (t, thy') =
8.776 + let
8.777 + fun analyse_type thy thf_ty =
8.778 + if #cautious config then
8.779 + case thf_ty of
8.780 + Fn_type (thf_ty1, thf_ty2) =>
8.781 + (analyse_type thy thf_ty1;
8.782 + analyse_type thy thf_ty2)
8.783 + | Atom_type ty_name =>
8.784 + if type_exists thy ty_name then ()
8.785 + else
8.786 + raise MISINTERPRET_TYPE
8.787 + ("This type, in signature of " ^
8.788 + name ^ " has not been declared.",
8.789 + Atom_type ty_name)
8.790 + | _ => ()
8.791 + else () (*skip test if we're not being cautious.*)
8.792 + in
8.793 + analyse_type thy tptp_ty;
8.794 + declare_constant config name ty thy
8.795 + end
8.796 + (*register a mapping from name to t. Constants' type
8.797 + declarations should occur at most once, so it's justified to
8.798 + use "::". Note that here we use a constant's name rather
8.799 + than the possibly- new one, since all references in the
8.800 + theory will be to this name.*)
8.801 + val const_map' = ((name, t) :: const_map)
8.802 + in ((type_map,(*type_map unchanged, since a constant's
8.803 + declaration shouldn't include any new types.*)
8.804 + const_map',(*typing table of constant was extended*)
8.805 + []),(*no formulas were interpreted*)
8.806 + thy')(*theory was extended with new constant*)
8.807 + end
8.808 + end
8.809 +
8.810 + | _ => (*i.e. the AF is not a type declaration*)
8.811 + let
8.812 + (*gather interpreted term, and the map of types occurring in that term*)
8.813 + val (t, thy') =
8.814 + interpret_formula config lang
8.815 + const_map [] type_map tptp_formula thy
8.816 + |>> HOLogic.mk_Trueprop
8.817 + (*type_maps grow monotonically, so return the newest value (type_mapped);
8.818 + there's no need to unify it with the type_map parameter.*)
8.819 + in
8.820 + ((type_map, const_map,
8.821 + [(label, role, tptp_formula,
8.822 + Syntax.check_term (Proof_Context.init_global thy') t,
8.823 + extract_inference_info annotation_opt)]), thy')
8.824 + end
8.825 +
8.826 +and interpret_problem new_basic_types config path_prefix lines type_map const_map thy =
8.827 + let
8.828 + val thy_name = Context.theory_name thy
8.829 + (*Add interpretation of $o and generate an Isabelle/HOL type to
8.830 + interpret $i, unless we've been given a mapping of types.*)
8.831 + val (thy', type_map') =
8.832 + if not new_basic_types then (thy, type_map)
8.833 + else
8.834 + let
8.835 + val (type_map', thy') =
8.836 + declare_type config
8.837 + (Defined_type Type_Ind, IND_TYPE) type_map thy
8.838 + in
8.839 + (thy', type_map')
8.840 + end
8.841 + in
8.842 + fold (fn line =>
8.843 + fn ((type_map, const_map, lines), thy) =>
8.844 + let
8.845 + (*process the line, ignoring the type-context for variables*)
8.846 + val ((type_map', const_map', l'), thy') =
8.847 + interpret_line config type_map const_map path_prefix line thy
8.848 + in
8.849 + ((type_map',
8.850 + const_map',
8.851 + l' @ lines),(*append is sufficient, union would be overkill*)
8.852 + thy')
8.853 + end)
8.854 + lines (*lines of the problem file*)
8.855 + ((type_map', const_map, []), thy') (*initial values*)
8.856 + end
8.857 +
8.858 +and interpret_file' new_basic_types config path_prefix file_name =
8.859 + let
8.860 + val file_name' = Path.expand file_name
8.861 + in
8.862 + if Path.is_absolute file_name' then
8.863 + Path.implode file_name
8.864 + |> TPTP_Parser.parse_file
8.865 + |> interpret_problem new_basic_types config path_prefix
8.866 + else error "Could not determine absolute path to file."
8.867 + end
8.868 +
8.869 +and interpret_file cautious path_prefix file_name =
8.870 + let
8.871 + val config =
8.872 + {cautious = cautious,
8.873 + problem_name =
8.874 + SOME (TPTP_Problem_Name.parse_problem_name ((Path.base #> Path.implode)
8.875 + file_name))
8.876 + }
8.877 + handle _(*FIXME*) =>
8.878 + {cautious = cautious,
8.879 + problem_name = NONE
8.880 + }
8.881 + in interpret_file' true config path_prefix file_name end
8.882 +
8.883 +fun import_file cautious path_prefix file_name type_map const_map thy =
8.884 + let
8.885 + val prob_name =
8.886 + TPTP_Problem_Name.parse_problem_name (Path.implode (Path.base file_name))
8.887 + handle _(*FIXME*) => TPTP_Problem_Name.Nonstandard (Path.implode file_name)
8.888 + val (result, thy') =
8.889 + interpret_file cautious path_prefix file_name type_map const_map thy
8.890 + in TPTP_Data.map (cons ((prob_name, result))) thy' end
8.891 +
8.892 +val _ =
8.893 + Outer_Syntax.improper_command "import_tptp" "import TPTP problem"
8.894 + Keyword.diag (*FIXME why diag?*)
8.895 + (Parse.string >>
8.896 + (fn file_name =>
8.897 + Toplevel.theory (fn thy =>
8.898 + import_file true (Path.explode file_name |> Path.dir)
8.899 + (Path.explode file_name) [] [] thy
8.900 + )))
8.901 +
8.902 +
8.903 +(*Used for debugging. Returns all files contained within a directory or its
8.904 +subdirectories. Follows symbolic links, filters away directories.*)
8.905 +fun get_file_list path =
8.906 + let
8.907 + fun check_file_entry f rest =
8.908 + let
8.909 + (*NOTE needed since don't have File.is_link and File.read_link*)
8.910 + val f_str = Path.implode f
8.911 + in
8.912 + if File.is_dir f then
8.913 + rest (*filter out directories*)
8.914 + else if OS.FileSys.isLink f_str then
8.915 + (*follow links -- NOTE this breaks if links are relative paths*)
8.916 + check_file_entry (Path.explode (OS.FileSys.readLink f_str)) rest
8.917 + else f :: rest
8.918 + end
8.919 + in
8.920 + File.read_dir path
8.921 + |> map
8.922 + (Path.explode
8.923 + #> Path.append path)
8.924 + |> (fn l => fold check_file_entry l [])
8.925 + end
8.926 +
8.927 +end
9.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
9.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp_lexyacc.ML Fri Mar 09 15:38:55 2012 +0000
9.3 @@ -0,0 +1,5594 @@
9.4 +
9.5 +(******************************************************************)
9.6 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
9.7 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
9.8 +(* GENERATED FILE -- DO NOT EDIT -- GENERATED FILE -- DO NOT EDIT *)
9.9 +(******************************************************************)
9.10 +
9.11 +(*
9.12 + This file is produced from the parser generated by ML-Yacc from the
9.13 + source files tptp.lex and tptp.yacc.
9.14 +*)
9.15 +signature TPTP_TOKENS =
9.16 +sig
9.17 +type ('a,'b) token
9.18 +type svalue
9.19 +val ITE_T: 'a * 'a -> (svalue,'a) token
9.20 +val ITE_F: 'a * 'a -> (svalue,'a) token
9.21 +val CNF: 'a * 'a -> (svalue,'a) token
9.22 +val FOF: 'a * 'a -> (svalue,'a) token
9.23 +val TFF: 'a * 'a -> (svalue,'a) token
9.24 +val THF: 'a * 'a -> (svalue,'a) token
9.25 +val LET_TERM: 'a * 'a -> (svalue,'a) token
9.26 +val SUBTYPE: 'a * 'a -> (svalue,'a) token
9.27 +val ATOMIC_SYSTEM_WORD: (string) * 'a * 'a -> (svalue,'a) token
9.28 +val ATOMIC_DEFINED_WORD: (string) * 'a * 'a -> (svalue,'a) token
9.29 +val DEP_PROD: 'a * 'a -> (svalue,'a) token
9.30 +val DEP_SUM: 'a * 'a -> (svalue,'a) token
9.31 +val GENTZEN_ARROW: 'a * 'a -> (svalue,'a) token
9.32 +val TIMES: 'a * 'a -> (svalue,'a) token
9.33 +val PLUS: 'a * 'a -> (svalue,'a) token
9.34 +val OPERATOR_EXISTS: 'a * 'a -> (svalue,'a) token
9.35 +val OPERATOR_FORALL: 'a * 'a -> (svalue,'a) token
9.36 +val DEFIN_CHOICE: 'a * 'a -> (svalue,'a) token
9.37 +val INDEF_CHOICE: 'a * 'a -> (svalue,'a) token
9.38 +val DUD: 'a * 'a -> (svalue,'a) token
9.39 +val DISTINCT_OBJECT: (string) * 'a * 'a -> (svalue,'a) token
9.40 +val COMMENT: (string) * 'a * 'a -> (svalue,'a) token
9.41 +val LOWER_WORD: (string) * 'a * 'a -> (svalue,'a) token
9.42 +val UPPER_WORD: (string) * 'a * 'a -> (svalue,'a) token
9.43 +val SINGLE_QUOTED: (string) * 'a * 'a -> (svalue,'a) token
9.44 +val DOT_DECIMAL: (string) * 'a * 'a -> (svalue,'a) token
9.45 +val UNSIGNED_INTEGER: (string) * 'a * 'a -> (svalue,'a) token
9.46 +val SIGNED_INTEGER: (string) * 'a * 'a -> (svalue,'a) token
9.47 +val RATIONAL: (string) * 'a * 'a -> (svalue,'a) token
9.48 +val REAL: (string) * 'a * 'a -> (svalue,'a) token
9.49 +val DTFF: 'a * 'a -> (svalue,'a) token
9.50 +val DFOT: 'a * 'a -> (svalue,'a) token
9.51 +val DCNF: 'a * 'a -> (svalue,'a) token
9.52 +val DFOF: 'a * 'a -> (svalue,'a) token
9.53 +val DTHF: 'a * 'a -> (svalue,'a) token
9.54 +val EOF: 'a * 'a -> (svalue,'a) token
9.55 +val VLINE: 'a * 'a -> (svalue,'a) token
9.56 +val TOK_TYPE: 'a * 'a -> (svalue,'a) token
9.57 +val TOK_TRUE: 'a * 'a -> (svalue,'a) token
9.58 +val TOK_RAT: 'a * 'a -> (svalue,'a) token
9.59 +val TOK_REAL: 'a * 'a -> (svalue,'a) token
9.60 +val TOK_INT: 'a * 'a -> (svalue,'a) token
9.61 +val TOK_O: 'a * 'a -> (svalue,'a) token
9.62 +val TOK_I: 'a * 'a -> (svalue,'a) token
9.63 +val TOK_FALSE: 'a * 'a -> (svalue,'a) token
9.64 +val TILDE: 'a * 'a -> (svalue,'a) token
9.65 +val RPAREN: 'a * 'a -> (svalue,'a) token
9.66 +val RBRKT: 'a * 'a -> (svalue,'a) token
9.67 +val QUESTION: 'a * 'a -> (svalue,'a) token
9.68 +val PPLUS: 'a * 'a -> (svalue,'a) token
9.69 +val PERIOD: 'a * 'a -> (svalue,'a) token
9.70 +val NOR: 'a * 'a -> (svalue,'a) token
9.71 +val XOR: 'a * 'a -> (svalue,'a) token
9.72 +val NEQUALS: 'a * 'a -> (svalue,'a) token
9.73 +val NAND: 'a * 'a -> (svalue,'a) token
9.74 +val MMINUS: 'a * 'a -> (svalue,'a) token
9.75 +val MAP_TO: 'a * 'a -> (svalue,'a) token
9.76 +val LPAREN: 'a * 'a -> (svalue,'a) token
9.77 +val LBRKT: 'a * 'a -> (svalue,'a) token
9.78 +val LAMBDA: 'a * 'a -> (svalue,'a) token
9.79 +val INCLUDE: 'a * 'a -> (svalue,'a) token
9.80 +val IMPLIES: 'a * 'a -> (svalue,'a) token
9.81 +val IFF: 'a * 'a -> (svalue,'a) token
9.82 +val IF: 'a * 'a -> (svalue,'a) token
9.83 +val ARROW: 'a * 'a -> (svalue,'a) token
9.84 +val LET: 'a * 'a -> (svalue,'a) token
9.85 +val EXCLAMATION: 'a * 'a -> (svalue,'a) token
9.86 +val EQUALS: 'a * 'a -> (svalue,'a) token
9.87 +val COMMA: 'a * 'a -> (svalue,'a) token
9.88 +val COLON: 'a * 'a -> (svalue,'a) token
9.89 +val CARET: 'a * 'a -> (svalue,'a) token
9.90 +val AT_SIGN: 'a * 'a -> (svalue,'a) token
9.91 +val AMPERSAND: 'a * 'a -> (svalue,'a) token
9.92 +end
9.93 +signature TPTP_LRVALS=
9.94 +sig
9.95 +structure Tokens : TPTP_TOKENS
9.96 +structure ParserData:PARSER_DATA
9.97 +sharing type ParserData.Token.token = Tokens.token
9.98 +sharing type ParserData.svalue = Tokens.svalue
9.99 +end
9.100 +functor TPTPLexFun(structure Tokens: TPTP_TOKENS)=
9.101 + struct
9.102 + structure UserDeclarations =
9.103 + struct
9.104 +(* Title: HOL/TPTP/TPTP_Parser/tptp.lex
9.105 + Author: Nik Sultana, Cambridge University Computer Laboratory
9.106 +
9.107 + Notes:
9.108 + * Omit %full in definitions to restrict alphabet to ascii.
9.109 + * Could include %posarg to ensure that start counting character positions from
9.110 + 0, but it would punish performance.
9.111 + * %s AF F COMMENT; -- could improve by making stateful.
9.112 +
9.113 + Acknowledgements:
9.114 + * Geoff Sutcliffe for help with TPTP.
9.115 + * Timothy Bourke for his tips on getting ML-Yacc working with Poly/ML.
9.116 + * An early version of this was ported from the specification shipped with
9.117 + Leo-II, written by Frank Theiss.
9.118 + * Some boilerplate bits were taken from the ml-yacc/ml-lex manual by Roger Price.
9.119 + * Jasmin Blanchette and Makarius Wenzel for help with Isabelle integration.
9.120 +*)
9.121 +
9.122 +structure T = Tokens
9.123 +type pos = int (* Position in file *)
9.124 +type lineNo = int
9.125 +type svalue = T.svalue
9.126 +type ('a,'b) token = ('a,'b) T.token
9.127 +type lexresult = (svalue,pos) token
9.128 +type lexarg = string
9.129 +type arg = lexarg
9.130 +val col = Unsynchronized.ref 0;
9.131 +val linep = Unsynchronized.ref 1; (* Line pointer *)
9.132 +val eolpos = Unsynchronized.ref 0;
9.133 +
9.134 +val badCh : string * string * int * int -> unit = fn
9.135 + (file_name, bad, line, col) =>
9.136 + TextIO.output(TextIO.stdOut, file_name ^ "["
9.137 + ^ Int.toString line ^ "." ^ Int.toString col
9.138 + ^ "] Invalid character \"" ^ bad ^ "\"\n");
9.139 +
9.140 +val eof = fn file_name =>
9.141 + let
9.142 + val result = T.EOF (!linep,!col);
9.143 + val _ = linep := 0;
9.144 + in result end
9.145 +(*here could check whether file ended prematurely:
9.146 + see if have open brackets, or if we're in some state other than INITIAL*)
9.147 +
9.148 +val count_commentlines : string -> unit = fn str =>
9.149 + let
9.150 + val str' = String.explode str
9.151 + val newlines = List.filter (fn x => x = #"\n") str'
9.152 + in linep := (!linep) + (List.length newlines) end
9.153 +
9.154 +end (* end of user routines *)
9.155 +exception LexError (* raised if illegal leaf action tried *)
9.156 +structure Internal =
9.157 + struct
9.158 +
9.159 +datatype yyfinstate = N of int
9.160 +type statedata = {fin : yyfinstate list, trans: string}
9.161 +(* transition & final state table *)
9.162 +val tab = let
9.163 +val s = [
9.164 + (0,
9.165 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.166 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.167 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.168 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.169 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.170 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.171 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.172 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.173 +\\000"
9.174 +),
9.175 + (1,
9.176 +"\000\000\000\000\000\000\000\000\000\134\136\000\000\135\000\000\
9.177 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.178 +\\134\130\124\000\102\090\089\083\082\081\080\078\077\072\070\057\
9.179 +\\048\048\048\048\048\048\048\048\048\048\045\000\039\037\036\033\
9.180 +\\030\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
9.181 +\\029\029\029\029\029\029\029\029\029\029\029\028\000\027\026\000\
9.182 +\\000\007\007\023\007\007\020\007\007\013\007\007\007\007\007\007\
9.183 +\\007\007\007\007\008\007\007\007\007\007\007\000\006\000\003\000\
9.184 +\\000"
9.185 +),
9.186 + (3,
9.187 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.188 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.189 +\\000\000\000\000\000\000\005\000\000\000\000\000\000\000\000\000\
9.190 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.191 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.192 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.193 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.194 +\\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\
9.195 +\\000"
9.196 +),
9.197 + (7,
9.198 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.199 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.200 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.201 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.202 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.203 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.204 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.205 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.206 +\\000"
9.207 +),
9.208 + (8,
9.209 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.210 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.211 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.212 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.213 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.214 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.215 +\\000\007\007\007\007\007\011\007\009\007\007\007\007\007\007\007\
9.216 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.217 +\\000"
9.218 +),
9.219 + (9,
9.220 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.221 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.222 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.223 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.224 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.225 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.226 +\\000\007\007\007\007\007\010\007\007\007\007\007\007\007\007\007\
9.227 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.228 +\\000"
9.229 +),
9.230 + (11,
9.231 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.232 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.233 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.234 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.235 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.236 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.237 +\\000\007\007\007\007\007\012\007\007\007\007\007\007\007\007\007\
9.238 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.239 +\\000"
9.240 +),
9.241 + (13,
9.242 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.243 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.244 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.245 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.246 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.247 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.248 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\014\007\
9.249 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.250 +\\000"
9.251 +),
9.252 + (14,
9.253 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.254 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.255 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.256 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.257 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.258 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.259 +\\000\007\007\015\007\007\007\007\007\007\007\007\007\007\007\007\
9.260 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.261 +\\000"
9.262 +),
9.263 + (15,
9.264 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.265 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.266 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.267 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.268 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.269 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.270 +\\000\007\007\007\007\007\007\007\007\007\007\007\016\007\007\007\
9.271 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.272 +\\000"
9.273 +),
9.274 + (16,
9.275 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.276 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.277 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.278 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.279 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.280 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.281 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.282 +\\007\007\007\007\007\017\007\007\007\007\007\000\000\000\000\000\
9.283 +\\000"
9.284 +),
9.285 + (17,
9.286 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.287 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.288 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.289 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.290 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.291 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.292 +\\000\007\007\007\018\007\007\007\007\007\007\007\007\007\007\007\
9.293 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.294 +\\000"
9.295 +),
9.296 + (18,
9.297 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.298 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.299 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.300 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.301 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.302 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.303 +\\000\007\007\007\007\019\007\007\007\007\007\007\007\007\007\007\
9.304 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.305 +\\000"
9.306 +),
9.307 + (20,
9.308 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.309 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.310 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.311 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.312 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.313 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.314 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\021\
9.315 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.316 +\\000"
9.317 +),
9.318 + (21,
9.319 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.320 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.321 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.322 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.323 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.324 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.325 +\\000\007\007\007\007\007\022\007\007\007\007\007\007\007\007\007\
9.326 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.327 +\\000"
9.328 +),
9.329 + (23,
9.330 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.331 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.332 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.333 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.334 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.335 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.336 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\024\007\
9.337 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.338 +\\000"
9.339 +),
9.340 + (24,
9.341 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.342 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.343 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.344 +\\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\000\
9.345 +\\000\007\007\007\007\007\007\007\007\007\007\007\007\007\007\007\
9.346 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\007\
9.347 +\\000\007\007\007\007\007\025\007\007\007\007\007\007\007\007\007\
9.348 +\\007\007\007\007\007\007\007\007\007\007\007\000\000\000\000\000\
9.349 +\\000"
9.350 +),
9.351 + (29,
9.352 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.353 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.354 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.355 +\\029\029\029\029\029\029\029\029\029\029\000\000\000\000\000\000\
9.356 +\\000\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
9.357 +\\029\029\029\029\029\029\029\029\029\029\029\000\000\000\000\029\
9.358 +\\000\029\029\029\029\029\029\029\029\029\029\029\029\029\029\029\
9.359 +\\029\029\029\029\029\029\029\029\029\029\029\000\000\000\000\000\
9.360 +\\000"
9.361 +),
9.362 + (30,
9.363 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.364 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.365 +\\000\000\000\000\000\000\000\000\000\000\000\032\000\031\000\000\
9.366 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.367 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.368 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.369 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.370 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.371 +\\000"
9.372 +),
9.373 + (33,
9.374 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.375 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.376 +\\000\000\000\000\000\000\000\000\000\000\035\000\000\000\000\000\
9.377 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\034\
9.378 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.379 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.380 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.381 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.382 +\\000"
9.383 +),
9.384 + (37,
9.385 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.386 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.387 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.388 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\038\000\
9.389 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.390 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.391 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.392 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.393 +\\000"
9.394 +),
9.395 + (39,
9.396 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.397 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.398 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.399 +\\000\000\000\000\000\000\000\000\000\000\000\000\044\042\000\000\
9.400 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.401 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.402 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.403 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\040\000\
9.404 +\\000"
9.405 +),
9.406 + (40,
9.407 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.408 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.409 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.410 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\041\000\
9.411 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.412 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.413 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.414 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.415 +\\000"
9.416 +),
9.417 + (42,
9.418 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.419 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.420 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.421 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\043\000\
9.422 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.423 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.424 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.425 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.426 +\\000"
9.427 +),
9.428 + (45,
9.429 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.430 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.431 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\047\000\000\
9.432 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\046\000\000\
9.433 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.434 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.435 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.436 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.437 +\\000"
9.438 +),
9.439 + (48,
9.440 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.441 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.442 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\051\049\
9.443 +\\048\048\048\048\048\048\048\048\048\048\000\000\000\000\000\000\
9.444 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.445 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.446 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.447 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.448 +\\000"
9.449 +),
9.450 + (49,
9.451 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.452 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.453 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.454 +\\050\050\050\050\050\050\050\050\050\050\000\000\000\000\000\000\
9.455 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.456 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.457 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.458 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.459 +\\000"
9.460 +),
9.461 + (51,
9.462 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.463 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.464 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.465 +\\052\052\052\052\052\052\052\052\052\052\000\000\000\000\000\000\
9.466 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.467 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.468 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.469 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.470 +\\000"
9.471 +),
9.472 + (52,
9.473 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.474 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.475 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.476 +\\052\052\052\052\052\052\052\052\052\052\000\000\000\000\000\000\
9.477 +\\000\000\000\000\000\053\000\000\000\000\000\000\000\000\000\000\
9.478 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.479 +\\000\000\000\000\000\053\000\000\000\000\000\000\000\000\000\000\
9.480 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.481 +\\000"
9.482 +),
9.483 + (53,
9.484 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.485 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.486 +\\000\000\000\000\000\000\000\000\000\000\000\055\000\055\000\000\
9.487 +\\054\054\054\054\054\054\054\054\054\054\000\000\000\000\000\000\
9.488 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.489 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.490 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.491 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.492 +\\000"
9.493 +),
9.494 + (54,
9.495 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.496 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.497 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.498 +\\054\054\054\054\054\054\054\054\054\054\000\000\000\000\000\000\
9.499 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.500 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.501 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.502 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.503 +\\000"
9.504 +),
9.505 + (55,
9.506 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.507 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.508 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.509 +\\056\056\056\056\056\056\056\056\056\056\000\000\000\000\000\000\
9.510 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.511 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.512 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.513 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.514 +\\000"
9.515 +),
9.516 + (57,
9.517 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.518 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.519 +\\000\000\000\000\000\000\000\000\000\000\058\000\000\000\000\000\
9.520 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.521 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.522 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.523 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.524 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.525 +\\000"
9.526 +),
9.527 + (58,
9.528 +"\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.529 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.530 +\\058\058\058\058\058\058\058\058\058\058\059\058\058\058\058\058\
9.531 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.532 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.533 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.534 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.535 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.536 +\\058"
9.537 +),
9.538 + (59,
9.539 +"\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.540 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.541 +\\058\058\058\058\058\058\058\058\058\058\059\058\058\058\058\060\
9.542 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.543 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.544 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.545 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.546 +\\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\058\
9.547 +\\058"
9.548 +),
9.549 + (60,
9.550 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.551 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.552 +\\000\000\000\000\000\064\000\000\000\000\000\000\000\000\000\061\
9.553 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.554 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.555 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.556 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.557 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.558 +\\000"
9.559 +),
9.560 + (61,
9.561 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.562 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.563 +\\000\000\000\000\000\000\000\000\000\000\062\000\000\000\000\000\
9.564 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.565 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.566 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.567 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.568 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.569 +\\000"
9.570 +),
9.571 + (62,
9.572 +"\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.573 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.574 +\\062\062\062\062\062\062\062\062\062\062\063\062\062\062\062\062\
9.575 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.576 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.577 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.578 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.579 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.580 +\\062"
9.581 +),
9.582 + (63,
9.583 +"\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.584 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.585 +\\062\062\062\062\062\062\062\062\062\062\063\062\062\062\062\060\
9.586 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.587 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.588 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.589 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.590 +\\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\062\
9.591 +\\062"
9.592 +),
9.593 + (64,
9.594 +"\064\064\064\064\064\064\064\064\064\064\000\064\064\064\064\064\
9.595 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.596 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\065\
9.597 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.598 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.599 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.600 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.601 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.602 +\\064"
9.603 +),
9.604 + (65,
9.605 +"\064\064\064\064\064\064\064\064\064\064\000\064\064\064\064\064\
9.606 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.607 +\\064\064\064\064\064\064\064\064\064\064\066\064\064\064\064\065\
9.608 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.609 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.610 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.611 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.612 +\\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\064\
9.613 +\\064"
9.614 +),
9.615 + (66,
9.616 +"\066\066\066\066\066\066\066\066\066\066\062\066\066\066\066\066\
9.617 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.618 +\\066\066\066\066\066\066\066\066\066\066\069\066\066\066\066\067\
9.619 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.620 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.621 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.622 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.623 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.624 +\\066"
9.625 +),
9.626 + (67,
9.627 +"\066\066\066\066\066\066\066\066\066\066\062\066\066\066\066\066\
9.628 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.629 +\\066\066\066\066\066\066\066\066\066\066\068\066\066\066\066\067\
9.630 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.631 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.632 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.633 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.634 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.635 +\\066"
9.636 +),
9.637 + (69,
9.638 +"\066\066\066\066\066\066\066\066\066\066\062\066\066\066\066\066\
9.639 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.640 +\\066\066\066\066\066\066\066\066\066\066\069\066\066\066\066\065\
9.641 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.642 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.643 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.644 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.645 +\\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\066\
9.646 +\\066"
9.647 +),
9.648 + (70,
9.649 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.650 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.651 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.652 +\\071\071\071\071\071\071\071\071\071\071\000\000\000\000\000\000\
9.653 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.654 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.655 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.656 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.657 +\\000"
9.658 +),
9.659 + (72,
9.660 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.661 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.662 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\075\000\000\
9.663 +\\074\074\074\074\074\074\074\074\074\074\000\000\000\000\073\000\
9.664 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.665 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.666 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.667 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.668 +\\000"
9.669 +),
9.670 + (74,
9.671 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.672 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.673 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\051\049\
9.674 +\\074\074\074\074\074\074\074\074\074\074\000\000\000\000\000\000\
9.675 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.676 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.677 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.678 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.679 +\\000"
9.680 +),
9.681 + (75,
9.682 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.683 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.684 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.685 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\076\000\
9.686 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.687 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.688 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.689 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.690 +\\000"
9.691 +),
9.692 + (78,
9.693 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.694 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.695 +\\000\000\000\000\000\000\000\000\000\000\000\079\000\000\000\000\
9.696 +\\074\074\074\074\074\074\074\074\074\074\000\000\000\000\000\000\
9.697 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.698 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.699 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.700 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.701 +\\000"
9.702 +),
9.703 + (83,
9.704 +"\000\000\000\000\000\000\000\000\000\084\000\000\000\000\000\000\
9.705 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.706 +\\084\000\000\000\000\000\000\000\084\084\000\084\084\084\084\084\
9.707 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.708 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.709 +\\084\084\084\084\084\084\084\084\084\084\084\084\088\084\084\084\
9.710 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.711 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\000\
9.712 +\\000"
9.713 +),
9.714 + (84,
9.715 +"\000\000\000\000\000\000\000\000\000\084\000\000\000\000\000\000\
9.716 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.717 +\\084\000\000\000\000\000\000\087\084\084\000\084\084\084\084\084\
9.718 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.719 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.720 +\\084\084\084\084\084\084\084\084\084\084\084\084\085\084\084\084\
9.721 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.722 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\000\
9.723 +\\000"
9.724 +),
9.725 + (85,
9.726 +"\000\000\000\000\000\000\000\000\000\084\000\000\000\000\000\000\
9.727 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.728 +\\084\000\000\000\000\000\000\086\084\084\000\084\084\084\084\084\
9.729 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.730 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.731 +\\084\084\084\084\084\084\084\084\084\084\084\084\085\084\084\084\
9.732 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\
9.733 +\\084\084\084\084\084\084\084\084\084\084\084\084\084\084\084\000\
9.734 +\\000"
9.735 +),
9.736 + (90,
9.737 +"\090\090\090\090\090\090\090\090\090\090\000\090\090\090\090\090\
9.738 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.739 +\\090\090\090\090\090\101\090\090\090\090\090\090\090\090\090\091\
9.740 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.741 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.742 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.743 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.744 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.745 +\\090"
9.746 +),
9.747 + (91,
9.748 +"\090\090\090\090\090\090\090\090\090\090\000\090\090\090\090\090\
9.749 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.750 +\\090\090\090\090\090\101\090\090\090\090\092\090\090\090\090\091\
9.751 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.752 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.753 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.754 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.755 +\\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\090\
9.756 +\\090"
9.757 +),
9.758 + (92,
9.759 +"\092\092\092\092\092\092\092\092\092\092\062\092\092\092\092\092\
9.760 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.761 +\\092\092\092\092\092\096\092\092\092\092\095\092\092\092\092\093\
9.762 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.763 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.764 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.765 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.766 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.767 +\\092"
9.768 +),
9.769 + (93,
9.770 +"\092\092\092\092\092\092\092\092\092\092\062\092\092\092\092\092\
9.771 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.772 +\\092\092\092\092\092\096\092\092\092\092\094\092\092\092\092\093\
9.773 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.774 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.775 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.776 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.777 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.778 +\\092"
9.779 +),
9.780 + (95,
9.781 +"\092\092\092\092\092\092\092\092\092\092\062\092\092\092\092\092\
9.782 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.783 +\\092\092\092\092\092\096\092\092\092\092\095\092\092\092\092\091\
9.784 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.785 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.786 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.787 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.788 +\\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\092\
9.789 +\\092"
9.790 +),
9.791 + (96,
9.792 +"\096\096\096\096\096\096\096\096\096\096\062\096\096\096\096\096\
9.793 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.794 +\\096\096\096\096\096\096\096\096\096\096\099\096\096\096\096\097\
9.795 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.796 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.797 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.798 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.799 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.800 +\\096"
9.801 +),
9.802 + (97,
9.803 +"\096\096\096\096\096\096\096\096\096\096\062\096\096\096\096\096\
9.804 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.805 +\\096\096\096\096\096\096\096\096\096\096\098\096\096\096\096\097\
9.806 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.807 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.808 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.809 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.810 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.811 +\\096"
9.812 +),
9.813 + (99,
9.814 +"\096\096\096\096\096\096\096\096\096\096\062\096\096\096\096\096\
9.815 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.816 +\\096\096\096\096\096\096\096\096\096\096\099\096\096\096\096\100\
9.817 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.818 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.819 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.820 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.821 +\\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\096\
9.822 +\\096"
9.823 +),
9.824 + (100,
9.825 +"\101\101\101\101\101\101\101\101\101\101\000\101\101\101\101\101\
9.826 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.827 +\\101\101\101\101\101\101\101\101\101\101\096\101\101\101\101\100\
9.828 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.829 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.830 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.831 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.832 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.833 +\\101"
9.834 +),
9.835 + (101,
9.836 +"\101\101\101\101\101\101\101\101\101\101\000\101\101\101\101\101\
9.837 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.838 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\100\
9.839 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.840 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.841 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.842 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.843 +\\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\101\
9.844 +\\101"
9.845 +),
9.846 + (102,
9.847 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.848 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.849 +\\000\000\000\000\122\000\000\000\000\000\000\000\000\000\000\000\
9.850 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.851 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.852 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.853 +\\000\103\103\119\103\103\115\103\103\109\103\103\103\103\103\103\
9.854 +\\103\103\103\103\104\103\103\103\103\103\103\000\000\000\000\000\
9.855 +\\000"
9.856 +),
9.857 + (103,
9.858 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.859 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.860 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.861 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.862 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.863 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.864 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.865 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.866 +\\000"
9.867 +),
9.868 + (104,
9.869 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.870 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.871 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.872 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.873 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.874 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.875 +\\000\103\103\103\103\103\107\103\105\103\103\103\103\103\103\103\
9.876 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.877 +\\000"
9.878 +),
9.879 + (105,
9.880 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.881 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.882 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.883 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.884 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.885 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.886 +\\000\103\103\103\103\103\106\103\103\103\103\103\103\103\103\103\
9.887 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.888 +\\000"
9.889 +),
9.890 + (107,
9.891 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.892 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.893 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.894 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.895 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.896 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.897 +\\000\103\103\103\103\103\108\103\103\103\103\103\103\103\103\103\
9.898 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.899 +\\000"
9.900 +),
9.901 + (109,
9.902 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.903 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.904 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.905 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.906 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.907 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.908 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.909 +\\103\103\103\103\110\103\103\103\103\103\103\000\000\000\000\000\
9.910 +\\000"
9.911 +),
9.912 + (110,
9.913 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.914 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.915 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.916 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.917 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.918 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.919 +\\000\103\103\103\103\111\103\103\103\103\103\103\103\103\103\103\
9.920 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.921 +\\000"
9.922 +),
9.923 + (111,
9.924 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.925 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.926 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.927 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.928 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.929 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\112\
9.930 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.931 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.932 +\\000"
9.933 +),
9.934 + (112,
9.935 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.936 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.937 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.938 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.939 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.940 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.941 +\\000\103\103\103\103\103\114\103\103\103\103\103\103\103\103\103\
9.942 +\\103\103\103\103\113\103\103\103\103\103\103\000\000\000\000\000\
9.943 +\\000"
9.944 +),
9.945 + (115,
9.946 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.947 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.948 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.949 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.950 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.951 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.952 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\116\
9.953 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.954 +\\000"
9.955 +),
9.956 + (116,
9.957 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.958 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.959 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.960 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.961 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.962 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.963 +\\000\103\103\103\103\103\118\103\103\103\103\103\103\103\103\103\
9.964 +\\103\103\103\103\117\103\103\103\103\103\103\000\000\000\000\000\
9.965 +\\000"
9.966 +),
9.967 + (119,
9.968 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.969 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.970 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.971 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.972 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.973 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.974 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\120\103\
9.975 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.976 +\\000"
9.977 +),
9.978 + (120,
9.979 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.980 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.981 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.982 +\\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\000\
9.983 +\\000\103\103\103\103\103\103\103\103\103\103\103\103\103\103\103\
9.984 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\103\
9.985 +\\000\103\103\103\103\103\121\103\103\103\103\103\103\103\103\103\
9.986 +\\103\103\103\103\103\103\103\103\103\103\103\000\000\000\000\000\
9.987 +\\000"
9.988 +),
9.989 + (122,
9.990 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.991 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.992 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.993 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.994 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.995 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.996 +\\000\123\123\123\123\123\123\123\123\123\123\123\123\123\123\123\
9.997 +\\123\123\123\123\123\123\123\123\123\123\123\000\000\000\000\000\
9.998 +\\000"
9.999 +),
9.1000 + (123,
9.1001 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1002 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1003 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1004 +\\123\123\123\123\123\123\123\123\123\123\000\000\000\000\000\000\
9.1005 +\\000\123\123\123\123\123\123\123\123\123\123\123\123\123\123\123\
9.1006 +\\123\123\123\123\123\123\123\123\123\123\123\000\000\000\000\123\
9.1007 +\\000\123\123\123\123\123\123\123\123\123\123\123\123\123\123\123\
9.1008 +\\123\123\123\123\123\123\123\123\123\123\123\000\000\000\000\000\
9.1009 +\\000"
9.1010 +),
9.1011 + (124,
9.1012 +"\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1013 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1014 +\\125\125\000\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1015 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1016 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1017 +\\125\125\125\125\125\125\125\125\125\125\125\125\129\125\125\125\
9.1018 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1019 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1020 +\\125"
9.1021 +),
9.1022 + (125,
9.1023 +"\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1024 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1025 +\\125\125\128\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1026 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1027 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1028 +\\125\125\125\125\125\125\125\125\125\125\125\125\126\125\125\125\
9.1029 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1030 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1031 +\\125"
9.1032 +),
9.1033 + (126,
9.1034 +"\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1035 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1036 +\\125\125\127\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1037 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1038 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1039 +\\125\125\125\125\125\125\125\125\125\125\125\125\126\125\125\125\
9.1040 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1041 +\\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\
9.1042 +\\125"
9.1043 +),
9.1044 + (130,
9.1045 +"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1046 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1047 +\\000\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1048 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\132\131\000\
9.1049 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1050 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1051 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1052 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1053 +\\000"
9.1054 +),
9.1055 + (134,
9.1056 +"\000\000\000\000\000\000\000\000\000\134\000\000\000\000\000\000\
9.1057 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1058 +\\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1059 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1060 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1061 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1062 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1063 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1064 +\\000"
9.1065 +),
9.1066 + (135,
9.1067 +"\000\000\000\000\000\000\000\000\000\000\136\000\000\000\000\000\
9.1068 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1069 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1070 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1071 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1072 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1073 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1074 +\\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
9.1075 +\\000"
9.1076 +),
9.1077 +(0, "")]
9.1078 +fun f x = x
9.1079 +val s = map f (rev (tl (rev s)))
9.1080 +exception LexHackingError
9.1081 +fun look ((j,x)::r, i: int) = if i = j then x else look(r, i)
9.1082 + | look ([], i) = raise LexHackingError
9.1083 +fun g {fin=x, trans=i} = {fin=x, trans=look(s,i)}
9.1084 +in Vector.fromList(map g
9.1085 +[{fin = [], trans = 0},
9.1086 +{fin = [(N 2)], trans = 1},
9.1087 +{fin = [(N 2)], trans = 1},
9.1088 +{fin = [(N 84)], trans = 3},
9.1089 +{fin = [(N 71)], trans = 0},
9.1090 +{fin = [(N 61)], trans = 0},
9.1091 +{fin = [(N 86)], trans = 0},
9.1092 +{fin = [(N 251)], trans = 7},
9.1093 +{fin = [(N 251)], trans = 8},
9.1094 +{fin = [(N 251)], trans = 9},
9.1095 +{fin = [(N 186),(N 251)], trans = 7},
9.1096 +{fin = [(N 251)], trans = 11},
9.1097 +{fin = [(N 198),(N 251)], trans = 7},
9.1098 +{fin = [(N 251)], trans = 13},
9.1099 +{fin = [(N 251)], trans = 14},
9.1100 +{fin = [(N 251)], trans = 15},
9.1101 +{fin = [(N 251)], trans = 16},
9.1102 +{fin = [(N 251)], trans = 17},
9.1103 +{fin = [(N 251)], trans = 18},
9.1104 +{fin = [(N 206),(N 251)], trans = 7},
9.1105 +{fin = [(N 251)], trans = 20},
9.1106 +{fin = [(N 251)], trans = 21},
9.1107 +{fin = [(N 190),(N 251)], trans = 7},
9.1108 +{fin = [(N 251)], trans = 23},
9.1109 +{fin = [(N 251)], trans = 24},
9.1110 +{fin = [(N 194),(N 251)], trans = 7},
9.1111 +{fin = [(N 25)], trans = 0},
9.1112 +{fin = [(N 80)], trans = 0},
9.1113 +{fin = [(N 50)], trans = 0},
9.1114 +{fin = [(N 157)], trans = 29},
9.1115 +{fin = [(N 23)], trans = 30},
9.1116 +{fin = [(N 15)], trans = 0},
9.1117 +{fin = [(N 12)], trans = 0},
9.1118 +{fin = [(N 78)], trans = 33},
9.1119 +{fin = [(N 21)], trans = 0},
9.1120 +{fin = [(N 283)], trans = 0},
9.1121 +{fin = [(N 38)], trans = 0},
9.1122 +{fin = [(N 31)], trans = 37},
9.1123 +{fin = [(N 48)], trans = 0},
9.1124 +{fin = [], trans = 39},
9.1125 +{fin = [], trans = 40},
9.1126 +{fin = [(N 68)], trans = 0},
9.1127 +{fin = [(N 41)], trans = 42},
9.1128 +{fin = [(N 45)], trans = 0},
9.1129 +{fin = [(N 277)], trans = 0},
9.1130 +{fin = [(N 27)], trans = 45},
9.1131 +{fin = [(N 36)], trans = 0},
9.1132 +{fin = [(N 286)], trans = 0},
9.1133 +{fin = [(N 126)], trans = 48},
9.1134 +{fin = [], trans = 49},
9.1135 +{fin = [(N 104)], trans = 49},
9.1136 +{fin = [], trans = 51},
9.1137 +{fin = [(N 119)], trans = 52},
9.1138 +{fin = [], trans = 53},
9.1139 +{fin = [(N 119)], trans = 54},
9.1140 +{fin = [], trans = 55},
9.1141 +{fin = [(N 119)], trans = 55},
9.1142 +{fin = [], trans = 57},
9.1143 +{fin = [], trans = 58},
9.1144 +{fin = [], trans = 59},
9.1145 +{fin = [(N 182)], trans = 60},
9.1146 +{fin = [], trans = 61},
9.1147 +{fin = [], trans = 62},
9.1148 +{fin = [], trans = 63},
9.1149 +{fin = [(N 182)], trans = 64},
9.1150 +{fin = [(N 182)], trans = 65},
9.1151 +{fin = [(N 182)], trans = 66},
9.1152 +{fin = [(N 182)], trans = 67},
9.1153 +{fin = [(N 182)], trans = 66},
9.1154 +{fin = [(N 182)], trans = 69},
9.1155 +{fin = [(N 73)], trans = 70},
9.1156 +{fin = [(N 130)], trans = 70},
9.1157 +{fin = [], trans = 72},
9.1158 +{fin = [(N 55)], trans = 0},
9.1159 +{fin = [(N 123)], trans = 74},
9.1160 +{fin = [(N 58)], trans = 75},
9.1161 +{fin = [(N 274)], trans = 0},
9.1162 +{fin = [(N 29)], trans = 0},
9.1163 +{fin = [(N 268)], trans = 78},
9.1164 +{fin = [(N 76)], trans = 0},
9.1165 +{fin = [(N 270)], trans = 0},
9.1166 +{fin = [(N 82)], trans = 0},
9.1167 +{fin = [(N 52)], trans = 0},
9.1168 +{fin = [], trans = 83},
9.1169 +{fin = [], trans = 84},
9.1170 +{fin = [], trans = 85},
9.1171 +{fin = [(N 151)], trans = 84},
9.1172 +{fin = [(N 151)], trans = 0},
9.1173 +{fin = [], trans = 85},
9.1174 +{fin = [(N 9)], trans = 0},
9.1175 +{fin = [(N 182)], trans = 90},
9.1176 +{fin = [(N 182)], trans = 91},
9.1177 +{fin = [(N 182)], trans = 92},
9.1178 +{fin = [(N 182)], trans = 93},
9.1179 +{fin = [(N 182)], trans = 92},
9.1180 +{fin = [(N 182)], trans = 95},
9.1181 +{fin = [(N 182)], trans = 96},
9.1182 +{fin = [(N 182)], trans = 97},
9.1183 +{fin = [(N 182)], trans = 96},
9.1184 +{fin = [(N 182)], trans = 99},
9.1185 +{fin = [(N 182)], trans = 100},
9.1186 +{fin = [(N 182)], trans = 101},
9.1187 +{fin = [], trans = 102},
9.1188 +{fin = [(N 266)], trans = 103},
9.1189 +{fin = [(N 266)], trans = 104},
9.1190 +{fin = [(N 266)], trans = 105},
9.1191 +{fin = [(N 211),(N 266)], trans = 103},
9.1192 +{fin = [(N 266)], trans = 107},
9.1193 +{fin = [(N 231),(N 266)], trans = 103},
9.1194 +{fin = [(N 266)], trans = 109},
9.1195 +{fin = [(N 266)], trans = 110},
9.1196 +{fin = [(N 266)], trans = 111},
9.1197 +{fin = [(N 266)], trans = 112},
9.1198 +{fin = [(N 245),(N 266)], trans = 103},
9.1199 +{fin = [(N 238),(N 266)], trans = 103},
9.1200 +{fin = [(N 266)], trans = 115},
9.1201 +{fin = [(N 266)], trans = 116},
9.1202 +{fin = [(N 226),(N 266)], trans = 103},
9.1203 +{fin = [(N 216),(N 266)], trans = 103},
9.1204 +{fin = [(N 266)], trans = 119},
9.1205 +{fin = [(N 266)], trans = 120},
9.1206 +{fin = [(N 221),(N 266)], trans = 103},
9.1207 +{fin = [], trans = 122},
9.1208 +{fin = [(N 259)], trans = 123},
9.1209 +{fin = [], trans = 124},
9.1210 +{fin = [], trans = 125},
9.1211 +{fin = [], trans = 126},
9.1212 +{fin = [(N 95)], trans = 125},
9.1213 +{fin = [(N 95)], trans = 0},
9.1214 +{fin = [], trans = 126},
9.1215 +{fin = [(N 33)], trans = 130},
9.1216 +{fin = [(N 280)], trans = 0},
9.1217 +{fin = [(N 64)], trans = 0},
9.1218 +{fin = [(N 18)], trans = 0},
9.1219 +{fin = [(N 2)], trans = 134},
9.1220 +{fin = [(N 7)], trans = 135},
9.1221 +{fin = [(N 7)], trans = 0}])
9.1222 +end
9.1223 +structure StartStates =
9.1224 + struct
9.1225 + datatype yystartstate = STARTSTATE of int
9.1226 +
9.1227 +(* start state definitions *)
9.1228 +
9.1229 +val INITIAL = STARTSTATE 1;
9.1230 +
9.1231 +end
9.1232 +type result = UserDeclarations.lexresult
9.1233 + exception LexerError (* raised if illegal leaf action tried *)
9.1234 +end
9.1235 +
9.1236 +fun makeLexer yyinput =
9.1237 +let val yygone0=1
9.1238 + val yyb = Unsynchronized.ref "\n" (* buffer *)
9.1239 + val yybl = Unsynchronized.ref 1 (*buffer length *)
9.1240 + val yybufpos = Unsynchronized.ref 1 (* location of next character to use *)
9.1241 + val yygone = Unsynchronized.ref yygone0 (* position in file of beginning of buffer *)
9.1242 + val yydone = Unsynchronized.ref false (* eof found yet? *)
9.1243 + val yybegin = Unsynchronized.ref 1 (*Current 'start state' for lexer *)
9.1244 +
9.1245 + val YYBEGIN = fn (Internal.StartStates.STARTSTATE x) =>
9.1246 + yybegin := x
9.1247 +
9.1248 +fun lex (yyarg as (file_name:string)) =
9.1249 +let fun continue() : Internal.result =
9.1250 + let fun scan (s,AcceptingLeaves : Internal.yyfinstate list list,l,i0) =
9.1251 + let fun action (i,nil) = raise LexError
9.1252 + | action (i,nil::l) = action (i-1,l)
9.1253 + | action (i,(node::acts)::l) =
9.1254 + case node of
9.1255 + Internal.N yyk =>
9.1256 + (let fun yymktext() = substring(!yyb,i0,i-i0)
9.1257 + val yypos = i0+ !yygone
9.1258 + open UserDeclarations Internal.StartStates
9.1259 + in (yybufpos := i; case yyk of
9.1260 +
9.1261 + (* Application actions *)
9.1262 +
9.1263 + 104 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.RATIONAL(yytext,!linep,!col) end
9.1264 +| 119 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.REAL(yytext,!linep,!col) end
9.1265 +| 12 => (col:=yypos-(!eolpos); T.INDEF_CHOICE(!linep,!col))
9.1266 +| 123 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.SIGNED_INTEGER(yytext,!linep,!col) end
9.1267 +| 126 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.UNSIGNED_INTEGER(yytext,!linep,!col) end
9.1268 +| 130 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.DOT_DECIMAL(yytext,!linep,!col) end
9.1269 +| 15 => (col:=yypos-(!eolpos); T.DEFIN_CHOICE(!linep,!col))
9.1270 +| 151 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.SINGLE_QUOTED(yytext,!linep,!col) end
9.1271 +| 157 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.UPPER_WORD(yytext,!linep,!col) end
9.1272 +| 18 => (col:=yypos-(!eolpos); T.OPERATOR_FORALL(!linep,!col))
9.1273 +| 182 => let val yytext=yymktext() in col:=yypos-(!eolpos); count_commentlines yytext;T.COMMENT(yytext,!linep,!col) end
9.1274 +| 186 => (col:=yypos-(!eolpos); T.THF(!linep,!col))
9.1275 +| 190 => (col:=yypos-(!eolpos); T.FOF(!linep,!col))
9.1276 +| 194 => (col:=yypos-(!eolpos); T.CNF(!linep,!col))
9.1277 +| 198 => (col:=yypos-(!eolpos); T.TFF(!linep,!col))
9.1278 +| 2 => let val yytext=yymktext() in col:=(!col)+size yytext; continue () end
9.1279 +| 206 => (col:=yypos-(!eolpos); T.INCLUDE(!linep,!col))
9.1280 +| 21 => (col:=yypos-(!eolpos); T.OPERATOR_EXISTS(!linep,!col))
9.1281 +| 211 => (col:=yypos-(!eolpos); T.DTHF(!linep,!col))
9.1282 +| 216 => (col:=yypos-(!eolpos); T.DFOF(!linep,!col))
9.1283 +| 221 => (col:=yypos-(!eolpos); T.DCNF(!linep,!col))
9.1284 +| 226 => (col:=yypos-(!eolpos); T.DFOT(!linep,!col))
9.1285 +| 23 => (col:=yypos-(!eolpos); T.AT_SIGN(!linep,!col))
9.1286 +| 231 => (col:=yypos-(!eolpos); T.DTFF(!linep,!col))
9.1287 +| 238 => (col:=yypos-(!eolpos); T.ITE_F(!linep,!col))
9.1288 +| 245 => (col:=yypos-(!eolpos); T.ITE_T(!linep,!col))
9.1289 +| 25 => (col:=yypos-(!eolpos); T.CARET(!linep,!col))
9.1290 +| 251 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.LOWER_WORD(yytext,!linep,!col) end
9.1291 +| 259 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.ATOMIC_SYSTEM_WORD(yytext,!linep,!col) end
9.1292 +| 266 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.ATOMIC_DEFINED_WORD(yytext,!linep,!col) end
9.1293 +| 268 => (col:=yypos-(!eolpos); T.PLUS(!linep,!col))
9.1294 +| 27 => (col:=yypos-(!eolpos); T.COLON(!linep,!col))
9.1295 +| 270 => (col:=yypos-(!eolpos); T.TIMES(!linep,!col))
9.1296 +| 274 => (col:=yypos-(!eolpos); T.GENTZEN_ARROW(!linep,!col))
9.1297 +| 277 => (col:=yypos-(!eolpos); T.SUBTYPE(!linep,!col))
9.1298 +| 280 => (col:=yypos-(!eolpos); T.DEP_PROD(!linep,!col))
9.1299 +| 283 => (col:=yypos-(!eolpos); T.DEP_SUM(!linep,!col))
9.1300 +| 286 => (col:=yypos-(!eolpos); T.LET_TERM(!linep,!col))
9.1301 +| 29 => (col:=yypos-(!eolpos); T.COMMA(!linep,!col))
9.1302 +| 31 => (col:=yypos-(!eolpos); T.EQUALS(!linep,!col))
9.1303 +| 33 => (col:=yypos-(!eolpos); T.EXCLAMATION(!linep,!col))
9.1304 +| 36 => (col:=yypos-(!eolpos); T.LET(!linep,!col))
9.1305 +| 38 => (col:=yypos-(!eolpos); T.ARROW(!linep,!col))
9.1306 +| 41 => (col:=yypos-(!eolpos); T.IF(!linep,!col))
9.1307 +| 45 => (col:=yypos-(!eolpos); T.IFF(!linep,!col))
9.1308 +| 48 => (col:=yypos-(!eolpos); T.IMPLIES(!linep,!col))
9.1309 +| 50 => (col:=yypos-(!eolpos); T.LBRKT(!linep,!col))
9.1310 +| 52 => (col:=yypos-(!eolpos); T.LPAREN(!linep,!col))
9.1311 +| 55 => (col:=yypos-(!eolpos); T.MAP_TO(!linep,!col))
9.1312 +| 58 => (col:=yypos-(!eolpos); T.MMINUS(!linep,!col))
9.1313 +| 61 => (col:=yypos-(!eolpos); T.NAND(!linep,!col))
9.1314 +| 64 => (col:=yypos-(!eolpos); T.NEQUALS(!linep,!col))
9.1315 +| 68 => (col:=yypos-(!eolpos); T.XOR(!linep,!col))
9.1316 +| 7 => let val yytext=yymktext() in linep:=(!linep)+1;
9.1317 + eolpos:=yypos+size yytext; continue () end
9.1318 +| 71 => (col:=yypos-(!eolpos); T.NOR(!linep,!col))
9.1319 +| 73 => (col:=yypos-(!eolpos); T.PERIOD(!linep,!col))
9.1320 +| 76 => (col:=yypos-(!eolpos); T.PPLUS(!linep,!col))
9.1321 +| 78 => (col:=yypos-(!eolpos); T.QUESTION(!linep,!col))
9.1322 +| 80 => (col:=yypos-(!eolpos); T.RBRKT(!linep,!col))
9.1323 +| 82 => (col:=yypos-(!eolpos); T.RPAREN(!linep,!col))
9.1324 +| 84 => (col:=yypos-(!eolpos); T.TILDE(!linep,!col))
9.1325 +| 86 => (col:=yypos-(!eolpos); T.VLINE(!linep,!col))
9.1326 +| 9 => (col:=yypos-(!eolpos); T.AMPERSAND(!linep,!col))
9.1327 +| 95 => let val yytext=yymktext() in col:=yypos-(!eolpos); T.DISTINCT_OBJECT(yytext,!linep,!col) end
9.1328 +| _ => raise Internal.LexerError
9.1329 +
9.1330 + ) end )
9.1331 +
9.1332 + val {fin,trans} = Vector.sub(Internal.tab, s)
9.1333 + val NewAcceptingLeaves = fin::AcceptingLeaves
9.1334 + in if l = !yybl then
9.1335 + if trans = #trans(Vector.sub(Internal.tab,0))
9.1336 + then action(l,NewAcceptingLeaves
9.1337 +) else let val newchars= if !yydone then "" else yyinput 1024
9.1338 + in if (size newchars)=0
9.1339 + then (yydone := true;
9.1340 + if (l=i0) then UserDeclarations.eof yyarg
9.1341 + else action(l,NewAcceptingLeaves))
9.1342 + else (if i0=l then yyb := newchars
9.1343 + else yyb := substring(!yyb,i0,l-i0)^newchars;
9.1344 + yygone := !yygone+i0;
9.1345 + yybl := size (!yyb);
9.1346 + scan (s,AcceptingLeaves,l-i0,0))
9.1347 + end
9.1348 + else let val NewChar = Char.ord(CharVector.sub(!yyb,l))
9.1349 + val NewChar = if NewChar<128 then NewChar else 128
9.1350 + val NewState = Char.ord(CharVector.sub(trans,NewChar))
9.1351 + in if NewState=0 then action(l,NewAcceptingLeaves)
9.1352 + else scan(NewState,NewAcceptingLeaves,l+1,i0)
9.1353 + end
9.1354 + end
9.1355 +(*
9.1356 + val start= if substring(!yyb,!yybufpos-1,1)="\n"
9.1357 +then !yybegin+1 else !yybegin
9.1358 +*)
9.1359 + in scan(!yybegin (* start *),nil,!yybufpos,!yybufpos)
9.1360 + end
9.1361 +in continue end
9.1362 + in lex
9.1363 + end
9.1364 +end
9.1365 +functor TPTPLrValsFun(structure Token : TOKEN)
9.1366 + : sig structure ParserData : PARSER_DATA
9.1367 + structure Tokens : TPTP_TOKENS
9.1368 + end
9.1369 + =
9.1370 +struct
9.1371 +structure ParserData=
9.1372 +struct
9.1373 +structure Header =
9.1374 +struct
9.1375 +open TPTP_Syntax
9.1376 +
9.1377 +exception UNRECOGNISED_SYMBOL of string * string
9.1378 +
9.1379 +exception UNRECOGNISED_ROLE of string
9.1380 +fun classify_role role =
9.1381 + case role of
9.1382 + "axiom" => Role_Axiom
9.1383 + | "hypothesis" => Role_Hypothesis
9.1384 + | "definition" => Role_Definition
9.1385 + | "assumption" => Role_Assumption
9.1386 + | "lemma" => Role_Lemma
9.1387 + | "theorem" => Role_Theorem
9.1388 + | "conjecture" => Role_Conjecture
9.1389 + | "negated_conjecture" => Role_Negated_Conjecture
9.1390 + | "plain" => Role_Plain
9.1391 + | "fi_domain" => Role_Fi_Domain
9.1392 + | "fi_functors" => Role_Fi_Functors
9.1393 + | "fi_predicates" => Role_Fi_Predicates
9.1394 + | "type" => Role_Type
9.1395 + | "unknown" => Role_Unknown
9.1396 + | thing => raise (UNRECOGNISED_ROLE thing)
9.1397 +
9.1398 +
9.1399 +end
9.1400 +structure LrTable = Token.LrTable
9.1401 +structure Token = Token
9.1402 +local open LrTable in
9.1403 +val table=let val actionRows =
9.1404 +"\
9.1405 +\\001\000\001\000\032\002\004\000\155\002\005\000\032\002\006\000\032\002\
9.1406 +\\010\000\032\002\011\000\032\002\012\000\032\002\016\000\212\000\
9.1407 +\\019\000\032\002\020\000\032\002\021\000\032\002\022\000\032\002\
9.1408 +\\027\000\032\002\037\000\032\002\000\000\
9.1409 +\\001\000\001\000\044\002\004\000\154\002\005\000\044\002\006\000\044\002\
9.1410 +\\010\000\044\002\011\000\044\002\012\000\044\002\016\000\217\000\
9.1411 +\\019\000\044\002\020\000\044\002\021\000\044\002\022\000\044\002\
9.1412 +\\027\000\044\002\037\000\044\002\000\000\
9.1413 +\\001\000\001\000\054\002\005\000\054\002\006\000\049\002\010\000\054\002\
9.1414 +\\011\000\054\002\012\000\054\002\019\000\054\002\020\000\049\002\
9.1415 +\\021\000\054\002\022\000\054\002\026\000\054\002\027\000\054\002\
9.1416 +\\037\000\054\002\000\000\
9.1417 +\\001\000\001\000\061\002\005\000\061\002\006\000\039\002\010\000\061\002\
9.1418 +\\011\000\061\002\012\000\061\002\019\000\061\002\020\000\039\002\
9.1419 +\\021\000\061\002\022\000\061\002\026\000\061\002\027\000\061\002\
9.1420 +\\037\000\061\002\000\000\
9.1421 +\\001\000\001\000\064\002\005\000\064\002\006\000\047\002\010\000\064\002\
9.1422 +\\011\000\064\002\012\000\064\002\019\000\064\002\020\000\047\002\
9.1423 +\\021\000\064\002\022\000\064\002\026\000\064\002\027\000\064\002\
9.1424 +\\037\000\064\002\000\000\
9.1425 +\\001\000\001\000\170\002\005\000\170\002\006\000\052\002\010\000\170\002\
9.1426 +\\011\000\170\002\012\000\170\002\019\000\170\002\020\000\052\002\
9.1427 +\\021\000\170\002\022\000\170\002\026\000\170\002\027\000\170\002\
9.1428 +\\037\000\170\002\000\000\
9.1429 +\\001\000\001\000\225\002\002\000\225\002\004\000\213\002\005\000\225\002\
9.1430 +\\006\000\225\002\008\000\225\002\009\000\225\002\010\000\225\002\
9.1431 +\\011\000\225\002\012\000\225\002\019\000\225\002\020\000\225\002\
9.1432 +\\021\000\225\002\022\000\225\002\026\000\225\002\027\000\225\002\
9.1433 +\\037\000\225\002\059\000\225\002\060\000\225\002\000\000\
9.1434 +\\001\000\001\000\228\002\002\000\228\002\004\000\214\002\005\000\228\002\
9.1435 +\\006\000\228\002\008\000\228\002\009\000\228\002\010\000\228\002\
9.1436 +\\011\000\228\002\012\000\228\002\019\000\228\002\020\000\228\002\
9.1437 +\\021\000\228\002\022\000\228\002\026\000\228\002\027\000\228\002\
9.1438 +\\037\000\228\002\059\000\228\002\060\000\228\002\000\000\
9.1439 +\\001\000\001\000\206\000\003\000\205\000\006\000\204\000\007\000\119\000\
9.1440 +\\008\000\203\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1441 +\\013\000\035\000\015\000\199\000\016\000\198\000\019\000\197\000\
9.1442 +\\020\000\196\000\021\000\195\000\022\000\194\000\025\000\116\000\
9.1443 +\\028\000\115\000\037\000\193\000\044\000\096\000\045\000\095\000\
9.1444 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1445 +\\051\000\031\000\053\000\093\000\055\000\192\000\056\000\191\000\
9.1446 +\\057\000\190\000\058\000\189\000\062\000\188\000\063\000\187\000\
9.1447 +\\064\000\092\000\065\000\091\000\068\000\030\000\069\000\029\000\
9.1448 +\\070\000\028\000\071\000\027\000\072\000\186\000\073\000\090\000\000\000\
9.1449 +\\001\000\001\000\206\000\003\000\205\000\006\000\204\000\007\000\119\000\
9.1450 +\\008\000\203\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1451 +\\013\000\035\000\016\000\024\001\019\000\197\000\020\000\196\000\
9.1452 +\\021\000\195\000\022\000\194\000\025\000\116\000\026\000\023\001\
9.1453 +\\028\000\115\000\037\000\193\000\044\000\096\000\045\000\095\000\
9.1454 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1455 +\\051\000\031\000\053\000\093\000\055\000\192\000\056\000\191\000\
9.1456 +\\057\000\190\000\058\000\189\000\062\000\188\000\063\000\187\000\
9.1457 +\\064\000\092\000\065\000\091\000\068\000\030\000\069\000\029\000\
9.1458 +\\070\000\028\000\071\000\027\000\072\000\186\000\073\000\090\000\000\000\
9.1459 +\\001\000\001\000\206\000\003\000\205\000\006\000\204\000\007\000\119\000\
9.1460 +\\008\000\203\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1461 +\\013\000\035\000\016\000\024\001\019\000\197\000\020\000\196\000\
9.1462 +\\021\000\195\000\022\000\194\000\025\000\116\000\028\000\115\000\
9.1463 +\\037\000\193\000\044\000\096\000\045\000\095\000\046\000\034\000\
9.1464 +\\047\000\033\000\049\000\032\000\050\000\094\000\051\000\031\000\
9.1465 +\\053\000\093\000\055\000\192\000\056\000\191\000\057\000\190\000\
9.1466 +\\058\000\189\000\062\000\188\000\063\000\187\000\064\000\092\000\
9.1467 +\\065\000\091\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1468 +\\071\000\027\000\072\000\186\000\073\000\090\000\000\000\
9.1469 +\\001\000\001\000\206\000\003\000\205\000\006\000\204\000\007\000\119\000\
9.1470 +\\008\000\203\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1471 +\\013\000\035\000\016\000\097\001\019\000\197\000\020\000\196\000\
9.1472 +\\021\000\195\000\022\000\194\000\025\000\116\000\028\000\115\000\
9.1473 +\\037\000\193\000\044\000\096\000\045\000\095\000\046\000\034\000\
9.1474 +\\047\000\033\000\049\000\032\000\050\000\094\000\051\000\031\000\
9.1475 +\\053\000\093\000\055\000\192\000\056\000\191\000\057\000\190\000\
9.1476 +\\058\000\189\000\062\000\188\000\063\000\187\000\064\000\092\000\
9.1477 +\\065\000\091\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1478 +\\071\000\027\000\072\000\186\000\073\000\090\000\000\000\
9.1479 +\\001\000\001\000\007\001\002\000\006\001\005\000\243\002\006\000\204\000\
9.1480 +\\008\000\243\002\009\000\210\002\010\000\202\000\011\000\201\000\
9.1481 +\\012\000\200\000\019\000\197\000\020\000\196\000\021\000\195\000\
9.1482 +\\022\000\194\000\026\000\243\002\027\000\243\002\037\000\005\001\
9.1483 +\\059\000\210\002\060\000\210\002\000\000\
9.1484 +\\001\000\004\000\243\000\000\000\
9.1485 +\\001\000\004\000\008\001\000\000\
9.1486 +\\001\000\004\000\193\001\000\000\
9.1487 +\\001\000\004\000\201\001\000\000\
9.1488 +\\001\000\004\000\205\001\000\000\
9.1489 +\\001\000\004\000\211\001\000\000\
9.1490 +\\001\000\004\000\216\001\000\000\
9.1491 +\\001\000\005\000\152\002\009\000\150\002\027\000\152\002\000\000\
9.1492 +\\001\000\005\000\041\000\000\000\
9.1493 +\\001\000\005\000\042\000\000\000\
9.1494 +\\001\000\005\000\043\000\000\000\
9.1495 +\\001\000\005\000\044\000\000\000\
9.1496 +\\001\000\005\000\054\000\000\000\
9.1497 +\\001\000\005\000\055\000\000\000\
9.1498 +\\001\000\005\000\056\000\000\000\
9.1499 +\\001\000\005\000\057\000\000\000\
9.1500 +\\001\000\005\000\147\001\000\000\
9.1501 +\\001\000\005\000\161\001\000\000\
9.1502 +\\001\000\005\000\174\001\000\000\
9.1503 +\\001\000\005\000\226\001\000\000\
9.1504 +\\001\000\005\000\232\001\000\000\
9.1505 +\\001\000\005\000\235\001\000\000\
9.1506 +\\001\000\006\000\204\000\000\000\
9.1507 +\\001\000\006\000\204\000\020\000\196\000\000\000\
9.1508 +\\001\000\007\000\119\000\008\000\146\000\013\000\035\000\015\000\145\000\
9.1509 +\\016\000\144\000\025\000\116\000\028\000\115\000\044\000\096\000\
9.1510 +\\045\000\095\000\046\000\034\000\047\000\033\000\049\000\032\000\
9.1511 +\\050\000\094\000\051\000\031\000\053\000\093\000\064\000\092\000\
9.1512 +\\065\000\091\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1513 +\\071\000\027\000\072\000\143\000\073\000\090\000\000\000\
9.1514 +\\001\000\007\000\119\000\008\000\146\000\013\000\035\000\016\000\247\000\
9.1515 +\\025\000\116\000\026\000\254\000\028\000\115\000\044\000\096\000\
9.1516 +\\045\000\095\000\046\000\034\000\047\000\033\000\049\000\032\000\
9.1517 +\\050\000\094\000\051\000\031\000\053\000\093\000\064\000\092\000\
9.1518 +\\065\000\091\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1519 +\\071\000\027\000\072\000\143\000\073\000\090\000\000\000\
9.1520 +\\001\000\007\000\119\000\008\000\146\000\013\000\035\000\016\000\247\000\
9.1521 +\\025\000\116\000\028\000\115\000\044\000\096\000\045\000\095\000\
9.1522 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1523 +\\051\000\031\000\053\000\093\000\064\000\092\000\065\000\091\000\
9.1524 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\
9.1525 +\\072\000\143\000\073\000\090\000\000\000\
9.1526 +\\001\000\007\000\119\000\013\000\035\000\015\000\118\000\016\000\117\000\
9.1527 +\\025\000\116\000\028\000\115\000\044\000\096\000\045\000\095\000\
9.1528 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1529 +\\051\000\031\000\053\000\093\000\064\000\092\000\065\000\091\000\
9.1530 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\
9.1531 +\\073\000\090\000\000\000\
9.1532 +\\001\000\007\000\119\000\013\000\035\000\016\000\231\000\025\000\116\000\
9.1533 +\\026\000\236\000\028\000\115\000\044\000\096\000\045\000\095\000\
9.1534 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1535 +\\051\000\031\000\053\000\093\000\064\000\092\000\065\000\091\000\
9.1536 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\
9.1537 +\\073\000\090\000\000\000\
9.1538 +\\001\000\007\000\119\000\013\000\035\000\016\000\231\000\025\000\116\000\
9.1539 +\\028\000\115\000\044\000\096\000\045\000\095\000\046\000\034\000\
9.1540 +\\047\000\033\000\049\000\032\000\050\000\094\000\051\000\031\000\
9.1541 +\\053\000\093\000\064\000\092\000\065\000\091\000\068\000\030\000\
9.1542 +\\069\000\029\000\070\000\028\000\071\000\027\000\073\000\090\000\000\000\
9.1543 +\\001\000\008\000\166\001\067\000\165\001\000\000\
9.1544 +\\001\000\008\000\176\001\000\000\
9.1545 +\\001\000\009\000\151\002\027\000\145\002\060\000\145\002\000\000\
9.1546 +\\001\000\009\000\011\001\059\000\010\001\060\000\009\001\000\000\
9.1547 +\\001\000\009\000\153\001\000\000\
9.1548 +\\001\000\013\000\035\000\015\000\042\001\026\000\142\001\039\000\041\001\
9.1549 +\\040\000\040\001\041\000\039\001\042\000\038\001\043\000\037\001\
9.1550 +\\044\000\096\000\045\000\095\000\046\000\034\000\047\000\033\000\
9.1551 +\\049\000\032\000\050\000\094\000\051\000\031\000\053\000\036\001\
9.1552 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\000\000\
9.1553 +\\001\000\013\000\035\000\015\000\042\001\039\000\041\001\040\000\040\001\
9.1554 +\\041\000\039\001\042\000\038\001\043\000\037\001\044\000\096\000\
9.1555 +\\045\000\095\000\046\000\034\000\047\000\033\000\049\000\032\000\
9.1556 +\\050\000\094\000\051\000\031\000\053\000\036\001\068\000\030\000\
9.1557 +\\069\000\029\000\070\000\028\000\071\000\027\000\000\000\
9.1558 +\\001\000\013\000\035\000\016\000\098\000\028\000\097\000\044\000\096\000\
9.1559 +\\045\000\095\000\046\000\034\000\047\000\033\000\049\000\032\000\
9.1560 +\\050\000\094\000\051\000\031\000\053\000\093\000\064\000\092\000\
9.1561 +\\065\000\091\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1562 +\\071\000\027\000\073\000\090\000\000\000\
9.1563 +\\001\000\013\000\035\000\016\000\078\001\049\000\032\000\051\000\031\000\
9.1564 +\\064\000\077\001\068\000\030\000\069\000\029\000\070\000\028\000\
9.1565 +\\071\000\027\000\000\000\
9.1566 +\\001\000\013\000\035\000\016\000\157\001\049\000\032\000\051\000\031\000\
9.1567 +\\064\000\077\001\068\000\030\000\069\000\029\000\070\000\028\000\
9.1568 +\\071\000\027\000\000\000\
9.1569 +\\001\000\013\000\035\000\028\000\097\000\044\000\096\000\045\000\095\000\
9.1570 +\\046\000\034\000\047\000\033\000\049\000\032\000\050\000\094\000\
9.1571 +\\051\000\031\000\053\000\093\000\064\000\092\000\065\000\091\000\
9.1572 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\
9.1573 +\\073\000\090\000\000\000\
9.1574 +\\001\000\013\000\035\000\044\000\096\000\045\000\095\000\046\000\034\000\
9.1575 +\\047\000\033\000\049\000\032\000\050\000\094\000\051\000\031\000\
9.1576 +\\053\000\093\000\064\000\092\000\065\000\091\000\068\000\030\000\
9.1577 +\\069\000\029\000\070\000\028\000\071\000\027\000\073\000\090\000\000\000\
9.1578 +\\001\000\013\000\035\000\046\000\034\000\047\000\033\000\049\000\032\000\
9.1579 +\\051\000\031\000\068\000\030\000\069\000\029\000\070\000\028\000\
9.1580 +\\071\000\027\000\000\000\
9.1581 +\\001\000\013\000\035\000\049\000\032\000\051\000\031\000\064\000\077\001\
9.1582 +\\068\000\030\000\069\000\029\000\070\000\028\000\071\000\027\000\000\000\
9.1583 +\\001\000\013\000\035\000\049\000\032\000\051\000\031\000\068\000\030\000\
9.1584 +\\069\000\029\000\070\000\028\000\071\000\027\000\000\000\
9.1585 +\\001\000\015\000\053\000\000\000\
9.1586 +\\001\000\015\000\118\000\000\000\
9.1587 +\\001\000\015\000\145\000\000\000\
9.1588 +\\001\000\015\000\199\000\000\000\
9.1589 +\\001\000\015\000\229\000\000\000\
9.1590 +\\001\000\015\000\245\000\000\000\
9.1591 +\\001\000\015\000\255\000\000\000\
9.1592 +\\001\000\015\000\015\001\000\000\
9.1593 +\\001\000\015\000\025\001\000\000\
9.1594 +\\001\000\015\000\042\001\000\000\
9.1595 +\\001\000\016\000\018\000\000\000\
9.1596 +\\001\000\016\000\019\000\000\000\
9.1597 +\\001\000\016\000\020\000\000\000\
9.1598 +\\001\000\016\000\021\000\000\000\
9.1599 +\\001\000\016\000\023\000\000\000\
9.1600 +\\001\000\016\000\218\000\000\000\
9.1601 +\\001\000\016\000\248\000\000\000\
9.1602 +\\001\000\016\000\018\001\000\000\
9.1603 +\\001\000\016\000\093\001\050\000\094\000\000\000\
9.1604 +\\001\000\016\000\129\001\050\000\094\000\000\000\
9.1605 +\\001\000\016\000\135\001\000\000\
9.1606 +\\001\000\016\000\136\001\000\000\
9.1607 +\\001\000\016\000\137\001\000\000\
9.1608 +\\001\000\016\000\138\001\000\000\
9.1609 +\\001\000\016\000\139\001\000\000\
9.1610 +\\001\000\023\000\058\000\000\000\
9.1611 +\\001\000\023\000\130\001\000\000\
9.1612 +\\001\000\023\000\148\001\000\000\
9.1613 +\\001\000\023\000\152\001\000\000\
9.1614 +\\001\000\023\000\168\001\000\000\
9.1615 +\\001\000\026\000\207\000\000\000\
9.1616 +\\001\000\026\000\064\001\000\000\
9.1617 +\\001\000\026\000\089\001\000\000\
9.1618 +\\001\000\026\000\125\001\000\000\
9.1619 +\\001\000\026\000\149\001\000\000\
9.1620 +\\001\000\026\000\158\001\000\000\
9.1621 +\\001\000\026\000\163\001\000\000\
9.1622 +\\001\000\026\000\170\001\000\000\
9.1623 +\\001\000\026\000\177\001\000\000\
9.1624 +\\001\000\026\000\190\001\000\000\
9.1625 +\\001\000\027\000\052\000\000\000\
9.1626 +\\001\000\027\000\027\001\000\000\
9.1627 +\\001\000\027\000\051\001\037\000\211\000\000\000\
9.1628 +\\001\000\027\000\052\001\000\000\
9.1629 +\\001\000\027\000\061\001\000\000\
9.1630 +\\001\000\027\000\062\001\000\000\
9.1631 +\\001\000\027\000\065\001\000\000\
9.1632 +\\001\000\027\000\085\001\000\000\
9.1633 +\\001\000\027\000\086\001\000\000\
9.1634 +\\001\000\027\000\087\001\000\000\
9.1635 +\\001\000\027\000\094\001\000\000\
9.1636 +\\001\000\027\000\122\001\000\000\
9.1637 +\\001\000\027\000\123\001\000\000\
9.1638 +\\001\000\027\000\143\001\000\000\
9.1639 +\\001\000\027\000\145\001\000\000\
9.1640 +\\001\000\027\000\146\001\000\000\
9.1641 +\\001\000\027\000\173\001\000\000\
9.1642 +\\001\000\027\000\197\001\000\000\
9.1643 +\\001\000\027\000\199\001\060\000\198\001\000\000\
9.1644 +\\001\000\027\000\209\001\000\000\
9.1645 +\\001\000\027\000\210\001\000\000\
9.1646 +\\001\000\027\000\218\001\000\000\
9.1647 +\\001\000\027\000\219\001\000\000\
9.1648 +\\001\000\027\000\220\001\000\000\
9.1649 +\\001\000\027\000\221\001\000\000\
9.1650 +\\001\000\027\000\222\001\000\000\
9.1651 +\\001\000\027\000\223\001\000\000\
9.1652 +\\001\000\027\000\224\001\000\000\
9.1653 +\\001\000\027\000\230\001\060\000\198\001\000\000\
9.1654 +\\001\000\027\000\240\001\000\000\
9.1655 +\\001\000\027\000\241\001\000\000\
9.1656 +\\001\000\027\000\242\001\000\000\
9.1657 +\\001\000\038\000\000\000\000\000\
9.1658 +\\001\000\049\000\040\000\000\000\
9.1659 +\\001\000\050\000\094\000\000\000\
9.1660 +\\001\000\051\000\048\000\000\000\
9.1661 +\\001\000\061\000\228\000\000\000\
9.1662 +\\001\000\061\000\244\000\000\000\
9.1663 +\\001\000\061\000\014\001\000\000\
9.1664 +\\244\001\000\000\
9.1665 +\\245\001\005\000\210\000\000\000\
9.1666 +\\246\001\000\000\
9.1667 +\\247\001\005\000\134\001\000\000\
9.1668 +\\248\001\000\000\
9.1669 +\\249\001\000\000\
9.1670 +\\250\001\000\000\
9.1671 +\\251\001\000\000\
9.1672 +\\252\001\005\000\189\001\000\000\
9.1673 +\\253\001\004\000\131\001\000\000\
9.1674 +\\254\001\000\000\
9.1675 +\\255\001\000\000\
9.1676 +\\000\002\000\000\
9.1677 +\\001\002\000\000\
9.1678 +\\002\002\000\000\
9.1679 +\\003\002\000\000\
9.1680 +\\004\002\000\000\
9.1681 +\\005\002\000\000\
9.1682 +\\006\002\000\000\
9.1683 +\\007\002\000\000\
9.1684 +\\008\002\000\000\
9.1685 +\\009\002\016\000\132\001\000\000\
9.1686 +\\010\002\000\000\
9.1687 +\\011\002\000\000\
9.1688 +\\012\002\000\000\
9.1689 +\\013\002\000\000\
9.1690 +\\014\002\000\000\
9.1691 +\\015\002\000\000\
9.1692 +\\016\002\000\000\
9.1693 +\\017\002\000\000\
9.1694 +\\018\002\000\000\
9.1695 +\\019\002\000\000\
9.1696 +\\020\002\000\000\
9.1697 +\\021\002\000\000\
9.1698 +\\022\002\000\000\
9.1699 +\\023\002\000\000\
9.1700 +\\024\002\000\000\
9.1701 +\\025\002\000\000\
9.1702 +\\027\002\000\000\
9.1703 +\\028\002\000\000\
9.1704 +\\029\002\005\000\144\001\000\000\
9.1705 +\\030\002\000\000\
9.1706 +\\031\002\000\000\
9.1707 +\\032\002\016\000\212\000\000\000\
9.1708 +\\033\002\000\000\
9.1709 +\\034\002\000\000\
9.1710 +\\035\002\000\000\
9.1711 +\\036\002\016\000\213\000\000\000\
9.1712 +\\037\002\000\000\
9.1713 +\\038\002\000\000\
9.1714 +\\039\002\000\000\
9.1715 +\\040\002\000\000\
9.1716 +\\041\002\000\000\
9.1717 +\\042\002\000\000\
9.1718 +\\043\002\000\000\
9.1719 +\\044\002\000\000\
9.1720 +\\044\002\016\000\217\000\000\000\
9.1721 +\\045\002\000\000\
9.1722 +\\045\002\066\000\017\001\000\000\
9.1723 +\\046\002\000\000\
9.1724 +\\047\002\000\000\
9.1725 +\\048\002\000\000\
9.1726 +\\049\002\000\000\
9.1727 +\\050\002\000\000\
9.1728 +\\051\002\000\000\
9.1729 +\\052\002\000\000\
9.1730 +\\053\002\000\000\
9.1731 +\\055\002\000\000\
9.1732 +\\056\002\000\000\
9.1733 +\\057\002\000\000\
9.1734 +\\058\002\000\000\
9.1735 +\\062\002\000\000\
9.1736 +\\063\002\000\000\
9.1737 +\\065\002\000\000\
9.1738 +\\066\002\000\000\
9.1739 +\\067\002\000\000\
9.1740 +\\068\002\000\000\
9.1741 +\\069\002\000\000\
9.1742 +\\070\002\000\000\
9.1743 +\\071\002\000\000\
9.1744 +\\072\002\000\000\
9.1745 +\\073\002\000\000\
9.1746 +\\074\002\000\000\
9.1747 +\\075\002\000\000\
9.1748 +\\076\002\000\000\
9.1749 +\\077\002\000\000\
9.1750 +\\078\002\000\000\
9.1751 +\\079\002\000\000\
9.1752 +\\080\002\000\000\
9.1753 +\\081\002\000\000\
9.1754 +\\082\002\000\000\
9.1755 +\\083\002\000\000\
9.1756 +\\084\002\000\000\
9.1757 +\\085\002\000\000\
9.1758 +\\086\002\000\000\
9.1759 +\\087\002\000\000\
9.1760 +\\088\002\000\000\
9.1761 +\\089\002\000\000\
9.1762 +\\090\002\000\000\
9.1763 +\\091\002\000\000\
9.1764 +\\092\002\000\000\
9.1765 +\\093\002\016\000\016\001\000\000\
9.1766 +\\094\002\000\000\
9.1767 +\\095\002\000\000\
9.1768 +\\096\002\000\000\
9.1769 +\\097\002\000\000\
9.1770 +\\098\002\000\000\
9.1771 +\\099\002\000\000\
9.1772 +\\100\002\037\000\211\000\000\000\
9.1773 +\\101\002\005\000\063\001\000\000\
9.1774 +\\102\002\000\000\
9.1775 +\\103\002\000\000\
9.1776 +\\104\002\000\000\
9.1777 +\\105\002\000\000\
9.1778 +\\106\002\000\000\
9.1779 +\\107\002\000\000\
9.1780 +\\108\002\000\000\
9.1781 +\\109\002\000\000\
9.1782 +\\110\002\005\000\150\001\000\000\
9.1783 +\\111\002\000\000\
9.1784 +\\112\002\000\000\
9.1785 +\\113\002\000\000\
9.1786 +\\114\002\000\000\
9.1787 +\\115\002\000\000\
9.1788 +\\116\002\000\000\
9.1789 +\\117\002\000\000\
9.1790 +\\118\002\000\000\
9.1791 +\\119\002\000\000\
9.1792 +\\120\002\000\000\
9.1793 +\\121\002\037\000\223\000\000\000\
9.1794 +\\122\002\001\000\224\000\000\000\
9.1795 +\\123\002\000\000\
9.1796 +\\124\002\000\000\
9.1797 +\\125\002\000\000\
9.1798 +\\126\002\000\000\
9.1799 +\\127\002\001\000\227\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1800 +\\019\000\197\000\021\000\195\000\022\000\194\000\037\000\226\000\000\000\
9.1801 +\\128\002\000\000\
9.1802 +\\129\002\000\000\
9.1803 +\\130\002\000\000\
9.1804 +\\131\002\000\000\
9.1805 +\\132\002\000\000\
9.1806 +\\133\002\005\000\088\001\000\000\
9.1807 +\\134\002\000\000\
9.1808 +\\135\002\000\000\
9.1809 +\\136\002\000\000\
9.1810 +\\137\002\000\000\
9.1811 +\\138\002\000\000\
9.1812 +\\139\002\000\000\
9.1813 +\\140\002\005\000\164\001\000\000\
9.1814 +\\141\002\000\000\
9.1815 +\\142\002\000\000\
9.1816 +\\143\002\000\000\
9.1817 +\\144\002\000\000\
9.1818 +\\146\002\000\000\
9.1819 +\\147\002\000\000\
9.1820 +\\148\002\000\000\
9.1821 +\\149\002\000\000\
9.1822 +\\150\002\060\000\196\001\000\000\
9.1823 +\\151\002\000\000\
9.1824 +\\153\002\000\000\
9.1825 +\\156\002\000\000\
9.1826 +\\157\002\000\000\
9.1827 +\\158\002\000\000\
9.1828 +\\159\002\000\000\
9.1829 +\\160\002\000\000\
9.1830 +\\161\002\000\000\
9.1831 +\\162\002\004\000\160\001\000\000\
9.1832 +\\163\002\005\000\159\001\000\000\
9.1833 +\\164\002\000\000\
9.1834 +\\165\002\000\000\
9.1835 +\\166\002\000\000\
9.1836 +\\167\002\000\000\
9.1837 +\\168\002\000\000\
9.1838 +\\169\002\000\000\
9.1839 +\\171\002\000\000\
9.1840 +\\172\002\000\000\
9.1841 +\\173\002\000\000\
9.1842 +\\174\002\000\000\
9.1843 +\\175\002\000\000\
9.1844 +\\176\002\000\000\
9.1845 +\\177\002\037\000\238\000\000\000\
9.1846 +\\178\002\001\000\239\000\000\000\
9.1847 +\\179\002\000\000\
9.1848 +\\180\002\000\000\
9.1849 +\\181\002\000\000\
9.1850 +\\182\002\000\000\
9.1851 +\\183\002\001\000\242\000\010\000\202\000\011\000\201\000\012\000\200\000\
9.1852 +\\019\000\197\000\021\000\195\000\022\000\194\000\037\000\241\000\000\000\
9.1853 +\\184\002\000\000\
9.1854 +\\185\002\000\000\
9.1855 +\\186\002\000\000\
9.1856 +\\187\002\000\000\
9.1857 +\\188\002\000\000\
9.1858 +\\189\002\005\000\124\001\000\000\
9.1859 +\\190\002\000\000\
9.1860 +\\191\002\000\000\
9.1861 +\\192\002\000\000\
9.1862 +\\193\002\000\000\
9.1863 +\\194\002\000\000\
9.1864 +\\195\002\000\000\
9.1865 +\\196\002\005\000\178\001\000\000\
9.1866 +\\197\002\000\000\
9.1867 +\\198\002\000\000\
9.1868 +\\199\002\000\000\
9.1869 +\\200\002\000\000\
9.1870 +\\201\002\000\000\
9.1871 +\\202\002\000\000\
9.1872 +\\203\002\000\000\
9.1873 +\\204\002\000\000\
9.1874 +\\205\002\009\000\011\001\000\000\
9.1875 +\\206\002\000\000\
9.1876 +\\207\002\000\000\
9.1877 +\\208\002\060\000\012\001\000\000\
9.1878 +\\209\002\059\000\013\001\000\000\
9.1879 +\\210\002\000\000\
9.1880 +\\211\002\000\000\
9.1881 +\\212\002\000\000\
9.1882 +\\215\002\000\000\
9.1883 +\\216\002\000\000\
9.1884 +\\217\002\000\000\
9.1885 +\\218\002\000\000\
9.1886 +\\219\002\004\000\172\001\000\000\
9.1887 +\\220\002\005\000\171\001\000\000\
9.1888 +\\221\002\000\000\
9.1889 +\\222\002\000\000\
9.1890 +\\223\002\000\000\
9.1891 +\\224\002\000\000\
9.1892 +\\225\002\000\000\
9.1893 +\\226\002\000\000\
9.1894 +\\227\002\000\000\
9.1895 +\\228\002\000\000\
9.1896 +\\229\002\000\000\
9.1897 +\\230\002\000\000\
9.1898 +\\231\002\000\000\
9.1899 +\\232\002\000\000\
9.1900 +\\233\002\000\000\
9.1901 +\\234\002\000\000\
9.1902 +\\235\002\037\000\001\001\000\000\
9.1903 +\\236\002\001\000\002\001\000\000\
9.1904 +\\237\002\002\000\003\001\000\000\
9.1905 +\\238\002\000\000\
9.1906 +\\239\002\000\000\
9.1907 +\\240\002\000\000\
9.1908 +\\241\002\000\000\
9.1909 +\\242\002\000\000\
9.1910 +\\244\002\000\000\
9.1911 +\\245\002\000\000\
9.1912 +\\246\002\000\000\
9.1913 +\\247\002\000\000\
9.1914 +\\248\002\000\000\
9.1915 +\\249\002\000\000\
9.1916 +\\250\002\000\000\
9.1917 +\\251\002\000\000\
9.1918 +\\252\002\000\000\
9.1919 +\\253\002\000\000\
9.1920 +\\254\002\000\000\
9.1921 +\\255\002\000\000\
9.1922 +\\000\003\000\000\
9.1923 +\\001\003\000\000\
9.1924 +\\002\003\000\000\
9.1925 +\\003\003\005\000\046\000\000\000\
9.1926 +\\004\003\000\000\
9.1927 +\\005\003\005\000\208\000\000\000\
9.1928 +\\006\003\000\000\
9.1929 +\\007\003\000\000\
9.1930 +\\008\003\000\000\
9.1931 +\\009\003\000\000\
9.1932 +\\010\003\000\000\
9.1933 +\\011\003\000\000\
9.1934 +\\012\003\013\000\016\000\052\000\015\000\068\000\014\000\069\000\013\000\
9.1935 +\\070\000\012\000\071\000\011\000\000\000\
9.1936 +\\013\003\000\000\
9.1937 +\"
9.1938 +val actionRowNumbers =
9.1939 +"\149\001\150\001\149\001\146\001\
9.1940 +\\145\001\137\001\136\001\135\001\
9.1941 +\\134\001\068\000\069\000\070\000\
9.1942 +\\071\000\149\001\072\000\147\001\
9.1943 +\\055\000\055\000\055\000\055\000\
9.1944 +\\148\001\131\000\144\001\143\001\
9.1945 +\\021\000\154\000\153\000\152\000\
9.1946 +\\151\000\149\000\150\000\167\000\
9.1947 +\\168\000\155\000\022\000\023\000\
9.1948 +\\024\000\140\001\169\000\133\000\
9.1949 +\\133\000\133\000\133\000\098\000\
9.1950 +\\058\000\025\000\129\001\026\000\
9.1951 +\\027\000\028\000\083\000\055\000\
9.1952 +\\050\000\040\000\037\000\008\000\
9.1953 +\\138\001\088\000\142\001\138\000\
9.1954 +\\245\000\242\000\241\000\239\000\
9.1955 +\\210\000\211\000\208\000\209\000\
9.1956 +\\212\000\203\000\201\000\004\000\
9.1957 +\\194\000\198\000\190\000\191\000\
9.1958 +\\003\000\185\000\002\000\181\000\
9.1959 +\\180\000\184\000\036\000\193\000\
9.1960 +\\164\000\188\000\202\000\176\000\
9.1961 +\\073\000\179\000\183\000\189\000\
9.1962 +\\156\000\166\000\165\000\054\000\
9.1963 +\\053\000\138\000\017\001\015\001\
9.1964 +\\013\001\014\001\010\001\011\001\
9.1965 +\\016\001\002\001\003\001\018\001\
9.1966 +\\134\000\254\000\062\000\042\000\
9.1967 +\\004\001\252\000\222\000\040\000\
9.1968 +\\041\000\221\000\138\000\068\001\
9.1969 +\\066\001\064\001\065\001\061\001\
9.1970 +\\062\001\067\001\051\001\052\001\
9.1971 +\\069\001\013\000\054\001\055\001\
9.1972 +\\070\001\135\000\044\001\063\000\
9.1973 +\\039\000\053\001\000\000\001\000\
9.1974 +\\005\000\074\000\037\000\038\000\
9.1975 +\\064\000\138\000\127\001\124\001\
9.1976 +\\121\001\122\001\117\001\118\001\
9.1977 +\\119\001\012\000\105\001\106\001\
9.1978 +\\125\001\014\000\126\001\046\000\
9.1979 +\\123\001\091\001\092\001\093\001\
9.1980 +\\006\000\108\001\109\001\128\001\
9.1981 +\\136\000\084\001\065\000\236\000\
9.1982 +\\238\000\229\000\228\000\237\000\
9.1983 +\\223\000\227\000\226\000\197\000\
9.1984 +\\195\000\187\000\199\000\083\001\
9.1985 +\\075\000\231\000\232\000\225\000\
9.1986 +\\224\000\234\000\233\000\213\000\
9.1987 +\\219\000\218\000\205\000\220\000\
9.1988 +\\008\000\009\000\216\000\215\000\
9.1989 +\\217\000\066\000\204\000\230\000\
9.1990 +\\214\000\139\001\055\000\099\000\
9.1991 +\\049\000\053\000\054\000\054\000\
9.1992 +\\054\000\054\000\206\000\054\000\
9.1993 +\\039\000\240\000\035\000\100\000\
9.1994 +\\101\000\042\000\042\000\042\000\
9.1995 +\\042\000\042\000\059\000\132\000\
9.1996 +\\253\000\042\000\102\000\103\000\
9.1997 +\\246\000\089\000\248\000\104\000\
9.1998 +\\039\000\039\000\039\000\039\000\
9.1999 +\\039\000\051\000\060\000\132\000\
9.2000 +\\043\001\039\000\039\000\105\000\
9.2001 +\\106\000\107\000\022\001\090\000\
9.2002 +\\019\001\076\000\108\000\011\000\
9.2003 +\\011\000\011\000\011\000\011\000\
9.2004 +\\011\000\011\000\010\000\011\000\
9.2005 +\\011\000\011\000\011\000\011\000\
9.2006 +\\061\000\132\000\010\000\057\000\
9.2007 +\\010\000\109\000\110\000\073\001\
9.2008 +\\091\000\071\001\010\000\077\000\
9.2009 +\\141\001\084\000\159\000\163\000\
9.2010 +\\161\000\160\000\146\000\158\000\
9.2011 +\\140\000\148\000\162\000\078\000\
9.2012 +\\079\000\080\000\081\000\082\000\
9.2013 +\\048\000\243\000\111\000\177\000\
9.2014 +\\112\000\207\000\235\000\113\000\
9.2015 +\\029\000\244\000\085\000\009\001\
9.2016 +\\007\001\012\001\008\001\006\001\
9.2017 +\\250\000\092\000\255\000\005\001\
9.2018 +\\251\000\042\000\249\000\086\000\
9.2019 +\\060\001\058\001\063\001\059\001\
9.2020 +\\057\001\041\001\047\000\020\000\
9.2021 +\\040\001\037\001\036\001\175\000\
9.2022 +\\052\000\023\001\093\000\048\001\
9.2023 +\\046\001\047\001\030\000\056\001\
9.2024 +\\042\001\024\001\039\000\020\001\
9.2025 +\\094\000\029\001\043\000\076\000\
9.2026 +\\087\000\116\001\107\001\010\000\
9.2027 +\\114\001\112\001\120\001\115\001\
9.2028 +\\111\001\113\001\095\001\097\001\
9.2029 +\\094\001\087\001\085\001\089\001\
9.2030 +\\090\001\088\001\086\001\075\001\
9.2031 +\\095\000\102\001\100\001\101\001\
9.2032 +\\114\000\096\001\192\000\031\000\
9.2033 +\\007\000\076\001\010\000\072\001\
9.2034 +\\044\000\096\000\080\001\077\000\
9.2035 +\\133\001\049\000\049\000\137\000\
9.2036 +\\067\000\037\000\054\000\050\000\
9.2037 +\\040\000\008\000\145\000\097\000\
9.2038 +\\143\000\182\000\054\000\186\000\
9.2039 +\\196\000\054\000\132\001\015\000\
9.2040 +\\132\000\247\000\131\001\056\000\
9.2041 +\\038\001\115\000\116\000\052\000\
9.2042 +\\016\000\132\000\056\000\039\000\
9.2043 +\\021\001\017\000\076\000\054\000\
9.2044 +\\039\000\117\000\130\001\118\000\
9.2045 +\\018\000\132\000\010\000\098\001\
9.2046 +\\010\000\074\001\010\000\019\000\
9.2047 +\\077\000\119\000\147\000\120\000\
9.2048 +\\139\000\141\000\121\000\122\000\
9.2049 +\\123\000\124\000\125\000\049\000\
9.2050 +\\142\000\178\000\032\000\042\000\
9.2051 +\\000\001\034\001\056\000\035\001\
9.2052 +\\056\000\039\001\126\000\039\000\
9.2053 +\\049\001\045\001\033\000\039\000\
9.2054 +\\030\001\027\001\026\001\028\001\
9.2055 +\\110\001\011\000\103\001\099\001\
9.2056 +\\034\000\078\001\011\000\081\001\
9.2057 +\\079\001\157\000\171\000\174\000\
9.2058 +\\173\000\172\000\170\000\144\000\
9.2059 +\\054\000\001\001\032\001\033\001\
9.2060 +\\045\000\050\001\039\000\031\001\
9.2061 +\\104\001\010\000\082\001\127\000\
9.2062 +\\128\000\129\000\200\000\025\001\
9.2063 +\\077\001\130\000"
9.2064 +val gotoT =
9.2065 +"\
9.2066 +\\133\000\008\000\134\000\007\000\135\000\006\000\136\000\005\000\
9.2067 +\\137\000\004\000\138\000\003\000\139\000\002\000\140\000\001\000\
9.2068 +\\141\000\241\001\000\000\
9.2069 +\\000\000\
9.2070 +\\133\000\008\000\134\000\007\000\135\000\006\000\136\000\005\000\
9.2071 +\\137\000\004\000\138\000\003\000\139\000\002\000\140\000\015\000\000\000\
9.2072 +\\000\000\
9.2073 +\\000\000\
9.2074 +\\000\000\
9.2075 +\\000\000\
9.2076 +\\000\000\
9.2077 +\\000\000\
9.2078 +\\000\000\
9.2079 +\\000\000\
9.2080 +\\000\000\
9.2081 +\\000\000\
9.2082 +\\133\000\008\000\134\000\007\000\135\000\006\000\136\000\005\000\
9.2083 +\\137\000\004\000\138\000\003\000\139\000\002\000\140\000\020\000\000\000\
9.2084 +\\000\000\
9.2085 +\\000\000\
9.2086 +\\002\000\024\000\009\000\023\000\014\000\022\000\000\000\
9.2087 +\\002\000\034\000\009\000\023\000\014\000\022\000\000\000\
9.2088 +\\002\000\035\000\009\000\023\000\014\000\022\000\000\000\
9.2089 +\\002\000\036\000\009\000\023\000\014\000\022\000\000\000\
9.2090 +\\000\000\
9.2091 +\\018\000\037\000\000\000\
9.2092 +\\000\000\
9.2093 +\\000\000\
9.2094 +\\000\000\
9.2095 +\\000\000\
9.2096 +\\000\000\
9.2097 +\\000\000\
9.2098 +\\000\000\
9.2099 +\\000\000\
9.2100 +\\000\000\
9.2101 +\\000\000\
9.2102 +\\000\000\
9.2103 +\\000\000\
9.2104 +\\000\000\
9.2105 +\\000\000\
9.2106 +\\000\000\
9.2107 +\\004\000\043\000\000\000\
9.2108 +\\000\000\
9.2109 +\\132\000\045\000\000\000\
9.2110 +\\132\000\047\000\000\000\
9.2111 +\\132\000\048\000\000\000\
9.2112 +\\132\000\049\000\000\000\
9.2113 +\\000\000\
9.2114 +\\000\000\
9.2115 +\\000\000\
9.2116 +\\000\000\
9.2117 +\\000\000\
9.2118 +\\000\000\
9.2119 +\\000\000\
9.2120 +\\000\000\
9.2121 +\\002\000\058\000\003\000\057\000\009\000\023\000\014\000\022\000\000\000\
9.2122 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2123 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2124 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2125 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2126 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2127 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2128 +\\045\000\063\000\055\000\062\000\057\000\061\000\058\000\060\000\
9.2129 +\\059\000\059\000\000\000\
9.2130 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2131 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2132 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2133 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2134 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2135 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2136 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2137 +\\061\000\108\000\062\000\107\000\063\000\106\000\065\000\105\000\
9.2138 +\\066\000\104\000\067\000\103\000\068\000\102\000\069\000\101\000\
9.2139 +\\070\000\100\000\071\000\099\000\072\000\098\000\073\000\097\000\000\000\
9.2140 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2141 +\\019\000\139\000\020\000\082\000\022\000\081\000\023\000\138\000\
9.2142 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2143 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2144 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2145 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2146 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2147 +\\074\000\133\000\076\000\132\000\077\000\131\000\080\000\130\000\
9.2148 +\\086\000\129\000\087\000\128\000\088\000\127\000\092\000\126\000\
9.2149 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2150 +\\097\000\121\000\098\000\120\000\099\000\119\000\100\000\118\000\000\000\
9.2151 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2152 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2153 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2154 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2155 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2156 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2157 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2158 +\\056\000\169\000\101\000\168\000\103\000\167\000\104\000\166\000\
9.2159 +\\107\000\165\000\108\000\164\000\109\000\163\000\110\000\162\000\
9.2160 +\\111\000\161\000\112\000\160\000\113\000\159\000\115\000\158\000\
9.2161 +\\116\000\157\000\117\000\156\000\118\000\155\000\122\000\154\000\
9.2162 +\\123\000\153\000\124\000\152\000\125\000\151\000\126\000\150\000\
9.2163 +\\127\000\149\000\128\000\148\000\129\000\147\000\130\000\146\000\
9.2164 +\\131\000\145\000\000\000\
9.2165 +\\000\000\
9.2166 +\\000\000\
9.2167 +\\000\000\
9.2168 +\\001\000\207\000\000\000\
9.2169 +\\000\000\
9.2170 +\\000\000\
9.2171 +\\000\000\
9.2172 +\\000\000\
9.2173 +\\000\000\
9.2174 +\\000\000\
9.2175 +\\000\000\
9.2176 +\\000\000\
9.2177 +\\000\000\
9.2178 +\\000\000\
9.2179 +\\000\000\
9.2180 +\\000\000\
9.2181 +\\000\000\
9.2182 +\\000\000\
9.2183 +\\000\000\
9.2184 +\\000\000\
9.2185 +\\000\000\
9.2186 +\\000\000\
9.2187 +\\000\000\
9.2188 +\\000\000\
9.2189 +\\000\000\
9.2190 +\\000\000\
9.2191 +\\036\000\214\000\037\000\213\000\038\000\212\000\000\000\
9.2192 +\\000\000\
9.2193 +\\000\000\
9.2194 +\\000\000\
9.2195 +\\000\000\
9.2196 +\\000\000\
9.2197 +\\000\000\
9.2198 +\\000\000\
9.2199 +\\000\000\
9.2200 +\\000\000\
9.2201 +\\000\000\
9.2202 +\\000\000\
9.2203 +\\000\000\
9.2204 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2205 +\\019\000\083\000\020\000\218\000\022\000\081\000\023\000\080\000\
9.2206 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2207 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2208 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2209 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2210 +\\045\000\217\000\000\000\
9.2211 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2212 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2213 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2214 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2215 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2216 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2217 +\\045\000\063\000\055\000\062\000\057\000\061\000\058\000\219\000\000\000\
9.2218 +\\001\000\220\000\000\000\
9.2219 +\\000\000\
9.2220 +\\000\000\
9.2221 +\\000\000\
9.2222 +\\000\000\
9.2223 +\\000\000\
9.2224 +\\000\000\
9.2225 +\\050\000\223\000\000\000\
9.2226 +\\000\000\
9.2227 +\\000\000\
9.2228 +\\000\000\
9.2229 +\\000\000\
9.2230 +\\000\000\
9.2231 +\\000\000\
9.2232 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2233 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2234 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2235 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2236 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2237 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2238 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2239 +\\063\000\106\000\065\000\105\000\066\000\228\000\000\000\
9.2240 +\\000\000\
9.2241 +\\000\000\
9.2242 +\\000\000\
9.2243 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2244 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2245 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2246 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2247 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2248 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2249 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2250 +\\061\000\108\000\062\000\231\000\063\000\106\000\065\000\105\000\
9.2251 +\\066\000\104\000\067\000\103\000\068\000\102\000\069\000\101\000\
9.2252 +\\070\000\100\000\071\000\099\000\072\000\230\000\000\000\
9.2253 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2254 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2255 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2256 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2257 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2258 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2259 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2260 +\\060\000\233\000\063\000\106\000\065\000\105\000\066\000\104\000\
9.2261 +\\067\000\103\000\068\000\102\000\069\000\101\000\070\000\100\000\
9.2262 +\\071\000\099\000\072\000\232\000\000\000\
9.2263 +\\000\000\
9.2264 +\\001\000\235\000\000\000\
9.2265 +\\000\000\
9.2266 +\\000\000\
9.2267 +\\000\000\
9.2268 +\\000\000\
9.2269 +\\000\000\
9.2270 +\\000\000\
9.2271 +\\050\000\238\000\000\000\
9.2272 +\\000\000\
9.2273 +\\000\000\
9.2274 +\\000\000\
9.2275 +\\000\000\
9.2276 +\\000\000\
9.2277 +\\000\000\
9.2278 +\\000\000\
9.2279 +\\000\000\
9.2280 +\\000\000\
9.2281 +\\000\000\
9.2282 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2283 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2284 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2285 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2286 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2287 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2288 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2289 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2290 +\\093\000\244\000\000\000\
9.2291 +\\000\000\
9.2292 +\\000\000\
9.2293 +\\000\000\
9.2294 +\\000\000\
9.2295 +\\000\000\
9.2296 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2297 +\\019\000\139\000\020\000\082\000\022\000\081\000\023\000\138\000\
9.2298 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2299 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2300 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2301 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2302 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2303 +\\074\000\133\000\076\000\249\000\077\000\131\000\080\000\130\000\
9.2304 +\\086\000\129\000\087\000\248\000\088\000\127\000\092\000\126\000\
9.2305 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2306 +\\097\000\121\000\098\000\120\000\099\000\247\000\000\000\
9.2307 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2308 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2309 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2310 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2311 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2312 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2313 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2314 +\\075\000\251\000\077\000\131\000\080\000\130\000\088\000\127\000\
9.2315 +\\092\000\126\000\093\000\125\000\094\000\124\000\095\000\123\000\
9.2316 +\\096\000\122\000\097\000\121\000\098\000\120\000\099\000\250\000\000\000\
9.2317 +\\000\000\
9.2318 +\\001\000\254\000\000\000\
9.2319 +\\000\000\
9.2320 +\\000\000\
9.2321 +\\000\000\
9.2322 +\\000\000\
9.2323 +\\000\000\
9.2324 +\\000\000\
9.2325 +\\000\000\
9.2326 +\\036\000\178\000\037\000\177\000\050\000\174\000\053\000\002\001\000\000\
9.2327 +\\000\000\
9.2328 +\\000\000\
9.2329 +\\000\000\
9.2330 +\\000\000\
9.2331 +\\000\000\
9.2332 +\\000\000\
9.2333 +\\000\000\
9.2334 +\\000\000\
9.2335 +\\000\000\
9.2336 +\\000\000\
9.2337 +\\000\000\
9.2338 +\\000\000\
9.2339 +\\000\000\
9.2340 +\\000\000\
9.2341 +\\000\000\
9.2342 +\\000\000\
9.2343 +\\000\000\
9.2344 +\\000\000\
9.2345 +\\000\000\
9.2346 +\\000\000\
9.2347 +\\000\000\
9.2348 +\\000\000\
9.2349 +\\000\000\
9.2350 +\\000\000\
9.2351 +\\000\000\
9.2352 +\\000\000\
9.2353 +\\000\000\
9.2354 +\\000\000\
9.2355 +\\000\000\
9.2356 +\\000\000\
9.2357 +\\000\000\
9.2358 +\\000\000\
9.2359 +\\000\000\
9.2360 +\\000\000\
9.2361 +\\000\000\
9.2362 +\\000\000\
9.2363 +\\000\000\
9.2364 +\\000\000\
9.2365 +\\000\000\
9.2366 +\\000\000\
9.2367 +\\000\000\
9.2368 +\\000\000\
9.2369 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2370 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2371 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2372 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2373 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2374 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2375 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2376 +\\056\000\169\000\101\000\168\000\103\000\018\001\104\000\166\000\
9.2377 +\\107\000\165\000\108\000\164\000\109\000\163\000\110\000\162\000\
9.2378 +\\111\000\161\000\112\000\160\000\113\000\159\000\115\000\158\000\
9.2379 +\\116\000\157\000\117\000\156\000\118\000\155\000\122\000\154\000\
9.2380 +\\123\000\153\000\124\000\152\000\125\000\151\000\126\000\150\000\
9.2381 +\\127\000\149\000\128\000\148\000\129\000\147\000\130\000\017\001\000\000\
9.2382 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2383 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2384 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2385 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2386 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2387 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2388 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2389 +\\056\000\169\000\102\000\020\001\104\000\166\000\107\000\165\000\
9.2390 +\\108\000\164\000\109\000\163\000\110\000\162\000\111\000\161\000\
9.2391 +\\112\000\160\000\113\000\159\000\115\000\158\000\116\000\157\000\
9.2392 +\\117\000\156\000\118\000\155\000\122\000\154\000\123\000\153\000\
9.2393 +\\124\000\152\000\125\000\151\000\126\000\150\000\127\000\149\000\
9.2394 +\\128\000\148\000\129\000\147\000\130\000\019\001\000\000\
9.2395 +\\000\000\
9.2396 +\\000\000\
9.2397 +\\000\000\
9.2398 +\\000\000\
9.2399 +\\000\000\
9.2400 +\\000\000\
9.2401 +\\000\000\
9.2402 +\\000\000\
9.2403 +\\002\000\058\000\003\000\024\001\009\000\023\000\014\000\022\000\000\000\
9.2404 +\\000\000\
9.2405 +\\006\000\033\001\008\000\032\001\009\000\031\001\010\000\030\001\
9.2406 +\\011\000\029\001\012\000\028\001\013\000\027\001\014\000\084\000\
9.2407 +\\016\000\026\001\000\000\
9.2408 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2409 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2410 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2411 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2412 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2413 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2414 +\\045\000\063\000\055\000\062\000\057\000\041\001\000\000\
9.2415 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2416 +\\019\000\083\000\020\000\043\001\021\000\042\001\022\000\081\000\
9.2417 +\\023\000\080\000\024\000\079\000\025\000\182\000\026\000\077\000\
9.2418 +\\027\000\181\000\028\000\075\000\029\000\074\000\030\000\073\000\
9.2419 +\\031\000\072\000\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2420 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2421 +\\019\000\083\000\020\000\043\001\021\000\044\001\022\000\081\000\
9.2422 +\\023\000\080\000\024\000\079\000\025\000\182\000\026\000\077\000\
9.2423 +\\027\000\181\000\028\000\075\000\029\000\074\000\030\000\073\000\
9.2424 +\\031\000\072\000\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2425 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2426 +\\019\000\083\000\020\000\045\001\022\000\081\000\023\000\080\000\
9.2427 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2428 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2429 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2430 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2431 +\\019\000\083\000\020\000\046\001\022\000\081\000\023\000\080\000\
9.2432 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2433 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2434 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2435 +\\000\000\
9.2436 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2437 +\\019\000\083\000\020\000\043\001\021\000\047\001\022\000\081\000\
9.2438 +\\023\000\080\000\024\000\079\000\025\000\182\000\026\000\077\000\
9.2439 +\\027\000\181\000\028\000\075\000\029\000\074\000\030\000\073\000\
9.2440 +\\031\000\072\000\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2441 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2442 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2443 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2444 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2445 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2446 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2447 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2448 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2449 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2450 +\\097\000\121\000\098\000\120\000\099\000\048\001\000\000\
9.2451 +\\000\000\
9.2452 +\\036\000\214\000\038\000\212\000\000\000\
9.2453 +\\000\000\
9.2454 +\\000\000\
9.2455 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2456 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2457 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2458 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2459 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2460 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2461 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2462 +\\063\000\106\000\065\000\105\000\066\000\051\001\000\000\
9.2463 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2464 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2465 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2466 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2467 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2468 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2469 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2470 +\\063\000\106\000\065\000\105\000\066\000\052\001\000\000\
9.2471 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2472 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2473 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2474 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2475 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2476 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2477 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2478 +\\063\000\106\000\065\000\105\000\066\000\053\001\000\000\
9.2479 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2480 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2481 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2482 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2483 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2484 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2485 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2486 +\\063\000\106\000\065\000\105\000\066\000\054\001\000\000\
9.2487 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2488 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2489 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2490 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2491 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2492 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2493 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2494 +\\063\000\106\000\065\000\105\000\066\000\055\001\000\000\
9.2495 +\\061\000\056\001\000\000\
9.2496 +\\011\000\058\001\064\000\057\001\000\000\
9.2497 +\\000\000\
9.2498 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2499 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2500 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2501 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2502 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2503 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2504 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2505 +\\063\000\106\000\065\000\105\000\066\000\104\000\067\000\103\000\
9.2506 +\\068\000\102\000\069\000\101\000\070\000\100\000\071\000\099\000\
9.2507 +\\072\000\230\000\000\000\
9.2508 +\\000\000\
9.2509 +\\000\000\
9.2510 +\\000\000\
9.2511 +\\000\000\
9.2512 +\\000\000\
9.2513 +\\000\000\
9.2514 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2515 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2516 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2517 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2518 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2519 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2520 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2521 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2522 +\\093\000\064\001\000\000\
9.2523 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2524 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2525 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2526 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2527 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2528 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2529 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2530 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2531 +\\093\000\065\001\000\000\
9.2532 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2533 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2534 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2535 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2536 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2537 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2538 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2539 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2540 +\\093\000\066\001\000\000\
9.2541 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2542 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2543 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2544 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2545 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2546 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2547 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2548 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2549 +\\093\000\067\001\000\000\
9.2550 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2551 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2552 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2553 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2554 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2555 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2556 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2557 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2558 +\\093\000\068\001\000\000\
9.2559 +\\009\000\074\001\047\000\073\001\082\000\072\001\083\000\071\001\
9.2560 +\\084\000\070\001\085\000\069\001\000\000\
9.2561 +\\074\000\077\001\000\000\
9.2562 +\\011\000\081\001\089\000\080\001\090\000\079\001\091\000\078\001\000\000\
9.2563 +\\000\000\
9.2564 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2565 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2566 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2567 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2568 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2569 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2570 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2571 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2572 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2573 +\\097\000\121\000\098\000\120\000\099\000\247\000\000\000\
9.2574 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2575 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2576 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2577 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2578 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2579 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2580 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2581 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.2582 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2583 +\\097\000\121\000\098\000\120\000\099\000\082\001\000\000\
9.2584 +\\000\000\
9.2585 +\\000\000\
9.2586 +\\000\000\
9.2587 +\\000\000\
9.2588 +\\000\000\
9.2589 +\\000\000\
9.2590 +\\011\000\090\001\078\000\089\001\079\000\088\001\000\000\
9.2591 +\\000\000\
9.2592 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2593 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2594 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2595 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2596 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2597 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2598 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2599 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2600 +\\118\000\155\000\122\000\154\000\123\000\093\001\000\000\
9.2601 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2602 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2603 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2604 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2605 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2606 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2607 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2608 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2609 +\\118\000\155\000\122\000\154\000\123\000\096\001\000\000\
9.2610 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2611 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2612 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2613 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2614 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2615 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2616 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2617 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2618 +\\118\000\155\000\122\000\154\000\123\000\097\001\000\000\
9.2619 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2620 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2621 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2622 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2623 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2624 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2625 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2626 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2627 +\\118\000\155\000\122\000\154\000\123\000\098\001\000\000\
9.2628 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2629 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2630 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2631 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2632 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2633 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2634 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2635 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2636 +\\118\000\155\000\122\000\154\000\123\000\099\001\000\000\
9.2637 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2638 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2639 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2640 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2641 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2642 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2643 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2644 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2645 +\\118\000\155\000\122\000\154\000\123\000\100\001\000\000\
9.2646 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2647 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2648 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2649 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2650 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2651 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2652 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2653 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2654 +\\118\000\155\000\122\000\154\000\123\000\101\001\000\000\
9.2655 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2656 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2657 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2658 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2659 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2660 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2661 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2662 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.2663 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.2664 +\\113\000\159\000\114\000\103\001\115\000\158\000\116\000\157\000\
9.2665 +\\117\000\156\000\118\000\155\000\122\000\154\000\123\000\153\000\
9.2666 +\\124\000\152\000\125\000\151\000\126\000\150\000\127\000\149\000\
9.2667 +\\128\000\148\000\129\000\147\000\130\000\102\001\000\000\
9.2668 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2669 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2670 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2671 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2672 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2673 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2674 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2675 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2676 +\\113\000\105\001\118\000\155\000\122\000\154\000\123\000\104\001\000\000\
9.2677 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2678 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2679 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2680 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2681 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2682 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2683 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2684 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2685 +\\113\000\106\001\118\000\155\000\122\000\154\000\123\000\104\001\000\000\
9.2686 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2687 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2688 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2689 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2690 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2691 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2692 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2693 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2694 +\\111\000\108\001\113\000\107\001\118\000\155\000\122\000\154\000\
9.2695 +\\123\000\104\001\000\000\
9.2696 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2697 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2698 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2699 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2700 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2701 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2702 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2703 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2704 +\\113\000\109\001\118\000\155\000\122\000\154\000\123\000\104\001\000\000\
9.2705 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2706 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2707 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2708 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2709 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2710 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2711 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2712 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.2713 +\\113\000\110\001\118\000\155\000\122\000\154\000\123\000\104\001\000\000\
9.2714 +\\101\000\111\001\000\000\
9.2715 +\\011\000\115\001\119\000\114\001\120\000\113\001\121\000\112\001\000\000\
9.2716 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2717 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2718 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2719 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2720 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2721 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2722 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2723 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.2724 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.2725 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.2726 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.2727 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.2728 +\\129\000\147\000\130\000\116\001\000\000\
9.2729 +\\009\000\087\000\019\000\118\001\031\000\117\001\000\000\
9.2730 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2731 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2732 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2733 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2734 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2735 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2736 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2737 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.2738 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.2739 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.2740 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.2741 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.2742 +\\129\000\147\000\130\000\119\001\000\000\
9.2743 +\\000\000\
9.2744 +\\000\000\
9.2745 +\\000\000\
9.2746 +\\000\000\
9.2747 +\\000\000\
9.2748 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2749 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2750 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2751 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2752 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2753 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2754 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2755 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.2756 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.2757 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.2758 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.2759 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.2760 +\\129\000\147\000\130\000\017\001\000\000\
9.2761 +\\011\000\115\001\105\000\126\001\106\000\125\001\119\000\114\001\
9.2762 +\\120\000\124\001\000\000\
9.2763 +\\000\000\
9.2764 +\\000\000\
9.2765 +\\000\000\
9.2766 +\\000\000\
9.2767 +\\000\000\
9.2768 +\\000\000\
9.2769 +\\000\000\
9.2770 +\\000\000\
9.2771 +\\005\000\131\001\000\000\
9.2772 +\\000\000\
9.2773 +\\000\000\
9.2774 +\\000\000\
9.2775 +\\000\000\
9.2776 +\\000\000\
9.2777 +\\000\000\
9.2778 +\\000\000\
9.2779 +\\006\000\033\001\007\000\139\001\008\000\138\001\009\000\031\001\
9.2780 +\\010\000\030\001\011\000\029\001\012\000\028\001\013\000\027\001\
9.2781 +\\014\000\084\000\016\000\026\001\000\000\
9.2782 +\\000\000\
9.2783 +\\000\000\
9.2784 +\\000\000\
9.2785 +\\000\000\
9.2786 +\\000\000\
9.2787 +\\000\000\
9.2788 +\\000\000\
9.2789 +\\000\000\
9.2790 +\\000\000\
9.2791 +\\000\000\
9.2792 +\\000\000\
9.2793 +\\000\000\
9.2794 +\\000\000\
9.2795 +\\000\000\
9.2796 +\\000\000\
9.2797 +\\000\000\
9.2798 +\\000\000\
9.2799 +\\000\000\
9.2800 +\\000\000\
9.2801 +\\000\000\
9.2802 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2803 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2804 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2805 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2806 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2807 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2808 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2809 +\\060\000\149\001\063\000\106\000\065\000\105\000\066\000\104\000\
9.2810 +\\067\000\103\000\068\000\102\000\069\000\101\000\070\000\100\000\
9.2811 +\\071\000\099\000\072\000\232\000\000\000\
9.2812 +\\000\000\
9.2813 +\\000\000\
9.2814 +\\000\000\
9.2815 +\\000\000\
9.2816 +\\000\000\
9.2817 +\\000\000\
9.2818 +\\000\000\
9.2819 +\\000\000\
9.2820 +\\000\000\
9.2821 +\\000\000\
9.2822 +\\000\000\
9.2823 +\\000\000\
9.2824 +\\000\000\
9.2825 +\\000\000\
9.2826 +\\009\000\074\001\047\000\073\001\081\000\154\001\082\000\153\001\
9.2827 +\\083\000\152\001\084\000\070\001\000\000\
9.2828 +\\000\000\
9.2829 +\\000\000\
9.2830 +\\000\000\
9.2831 +\\000\000\
9.2832 +\\000\000\
9.2833 +\\000\000\
9.2834 +\\000\000\
9.2835 +\\000\000\
9.2836 +\\000\000\
9.2837 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2838 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2839 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2840 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2841 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2842 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2843 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2844 +\\075\000\160\001\077\000\131\000\080\000\130\000\088\000\127\000\
9.2845 +\\092\000\126\000\093\000\125\000\094\000\124\000\095\000\123\000\
9.2846 +\\096\000\122\000\097\000\121\000\098\000\120\000\099\000\250\000\000\000\
9.2847 +\\000\000\
9.2848 +\\000\000\
9.2849 +\\000\000\
9.2850 +\\000\000\
9.2851 +\\011\000\090\001\078\000\165\001\000\000\
9.2852 +\\000\000\
9.2853 +\\000\000\
9.2854 +\\000\000\
9.2855 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2856 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2857 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2858 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2859 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2860 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2861 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2862 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.2863 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.2864 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.2865 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.2866 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.2867 +\\129\000\147\000\130\000\167\001\000\000\
9.2868 +\\000\000\
9.2869 +\\000\000\
9.2870 +\\000\000\
9.2871 +\\000\000\
9.2872 +\\000\000\
9.2873 +\\000\000\
9.2874 +\\000\000\
9.2875 +\\000\000\
9.2876 +\\000\000\
9.2877 +\\000\000\
9.2878 +\\000\000\
9.2879 +\\000\000\
9.2880 +\\000\000\
9.2881 +\\000\000\
9.2882 +\\000\000\
9.2883 +\\000\000\
9.2884 +\\000\000\
9.2885 +\\000\000\
9.2886 +\\000\000\
9.2887 +\\000\000\
9.2888 +\\000\000\
9.2889 +\\000\000\
9.2890 +\\000\000\
9.2891 +\\000\000\
9.2892 +\\000\000\
9.2893 +\\000\000\
9.2894 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2895 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2896 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2897 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2898 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2899 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2900 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2901 +\\056\000\169\000\102\000\173\001\104\000\166\000\107\000\165\000\
9.2902 +\\108\000\164\000\109\000\163\000\110\000\162\000\111\000\161\000\
9.2903 +\\112\000\160\000\113\000\159\000\115\000\158\000\116\000\157\000\
9.2904 +\\117\000\156\000\118\000\155\000\122\000\154\000\123\000\153\000\
9.2905 +\\124\000\152\000\125\000\151\000\126\000\150\000\127\000\149\000\
9.2906 +\\128\000\148\000\129\000\147\000\130\000\019\001\000\000\
9.2907 +\\000\000\
9.2908 +\\000\000\
9.2909 +\\000\000\
9.2910 +\\000\000\
9.2911 +\\011\000\115\001\105\000\177\001\119\000\114\001\120\000\124\001\000\000\
9.2912 +\\000\000\
9.2913 +\\006\000\033\001\008\000\178\001\009\000\031\001\010\000\030\001\
9.2914 +\\011\000\029\001\012\000\028\001\013\000\027\001\014\000\084\000\
9.2915 +\\016\000\026\001\000\000\
9.2916 +\\006\000\033\001\007\000\179\001\008\000\138\001\009\000\031\001\
9.2917 +\\010\000\030\001\011\000\029\001\012\000\028\001\013\000\027\001\
9.2918 +\\014\000\084\000\016\000\026\001\000\000\
9.2919 +\\000\000\
9.2920 +\\006\000\181\001\017\000\180\001\000\000\
9.2921 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.2922 +\\019\000\139\000\020\000\082\000\022\000\081\000\023\000\138\000\
9.2923 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2924 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2925 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2926 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2927 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.2928 +\\074\000\133\000\076\000\132\000\077\000\131\000\080\000\130\000\
9.2929 +\\086\000\129\000\087\000\128\000\088\000\127\000\092\000\126\000\
9.2930 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.2931 +\\097\000\121\000\098\000\120\000\099\000\119\000\100\000\182\001\000\000\
9.2932 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2933 +\\019\000\083\000\020\000\183\001\022\000\081\000\023\000\080\000\
9.2934 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2935 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2936 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2937 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2938 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2939 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2940 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2941 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2942 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2943 +\\045\000\063\000\055\000\062\000\057\000\061\000\058\000\060\000\
9.2944 +\\059\000\184\001\000\000\
9.2945 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2946 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.2947 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.2948 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2949 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.2950 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.2951 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.2952 +\\061\000\108\000\062\000\107\000\063\000\106\000\065\000\105\000\
9.2953 +\\066\000\104\000\067\000\103\000\068\000\102\000\069\000\101\000\
9.2954 +\\070\000\100\000\071\000\099\000\072\000\098\000\073\000\185\001\000\000\
9.2955 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2956 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.2957 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2958 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.2959 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.2960 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.2961 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.2962 +\\056\000\169\000\101\000\168\000\103\000\167\000\104\000\166\000\
9.2963 +\\107\000\165\000\108\000\164\000\109\000\163\000\110\000\162\000\
9.2964 +\\111\000\161\000\112\000\160\000\113\000\159\000\115\000\158\000\
9.2965 +\\116\000\157\000\117\000\156\000\118\000\155\000\122\000\154\000\
9.2966 +\\123\000\153\000\124\000\152\000\125\000\151\000\126\000\150\000\
9.2967 +\\127\000\149\000\128\000\148\000\129\000\147\000\130\000\146\000\
9.2968 +\\131\000\186\001\000\000\
9.2969 +\\000\000\
9.2970 +\\000\000\
9.2971 +\\000\000\
9.2972 +\\000\000\
9.2973 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2974 +\\019\000\083\000\020\000\043\001\021\000\189\001\022\000\081\000\
9.2975 +\\023\000\080\000\024\000\079\000\025\000\182\000\026\000\077\000\
9.2976 +\\027\000\181\000\028\000\075\000\029\000\074\000\030\000\073\000\
9.2977 +\\031\000\072\000\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2978 +\\000\000\
9.2979 +\\000\000\
9.2980 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.2981 +\\019\000\083\000\020\000\190\001\022\000\081\000\023\000\080\000\
9.2982 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.2983 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.2984 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.2985 +\\000\000\
9.2986 +\\000\000\
9.2987 +\\011\000\058\001\064\000\192\001\000\000\
9.2988 +\\000\000\
9.2989 +\\000\000\
9.2990 +\\009\000\074\001\047\000\073\001\083\000\193\001\000\000\
9.2991 +\\000\000\
9.2992 +\\000\000\
9.2993 +\\000\000\
9.2994 +\\009\000\074\001\047\000\073\001\081\000\198\001\082\000\153\001\
9.2995 +\\083\000\152\001\084\000\070\001\000\000\
9.2996 +\\000\000\
9.2997 +\\011\000\081\001\089\000\080\001\090\000\079\001\091\000\200\001\000\000\
9.2998 +\\009\000\074\001\047\000\073\001\083\000\201\001\000\000\
9.2999 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.3000 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3001 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3002 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3003 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3004 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3005 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.3006 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.3007 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.3008 +\\097\000\121\000\098\000\120\000\099\000\202\001\000\000\
9.3009 +\\000\000\
9.3010 +\\000\000\
9.3011 +\\011\000\090\001\078\000\089\001\079\000\204\001\000\000\
9.3012 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3013 +\\019\000\083\000\020\000\205\001\022\000\081\000\023\000\080\000\
9.3014 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3015 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3016 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.3017 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.3018 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3019 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3020 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3021 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3022 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3023 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.3024 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.3025 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.3026 +\\097\000\121\000\098\000\120\000\099\000\206\001\000\000\
9.3027 +\\000\000\
9.3028 +\\000\000\
9.3029 +\\000\000\
9.3030 +\\000\000\
9.3031 +\\011\000\115\001\119\000\114\001\120\000\113\001\121\000\210\001\000\000\
9.3032 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3033 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3034 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3035 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.3036 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3037 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3038 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3039 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.3040 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.3041 +\\113\000\159\000\114\000\211\001\115\000\158\000\116\000\157\000\
9.3042 +\\117\000\156\000\118\000\155\000\122\000\154\000\123\000\153\000\
9.3043 +\\124\000\152\000\125\000\151\000\126\000\150\000\127\000\149\000\
9.3044 +\\128\000\148\000\129\000\147\000\130\000\102\001\000\000\
9.3045 +\\000\000\
9.3046 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3047 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3048 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3049 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.3050 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3051 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3052 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3053 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.3054 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.3055 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.3056 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.3057 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.3058 +\\129\000\147\000\130\000\212\001\000\000\
9.3059 +\\000\000\
9.3060 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3061 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3062 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3063 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.3064 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3065 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3066 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3067 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.3068 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.3069 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.3070 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.3071 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.3072 +\\129\000\147\000\130\000\213\001\000\000\
9.3073 +\\000\000\
9.3074 +\\011\000\115\001\105\000\126\001\106\000\215\001\119\000\114\001\
9.3075 +\\120\000\124\001\000\000\
9.3076 +\\000\000\
9.3077 +\\000\000\
9.3078 +\\000\000\
9.3079 +\\000\000\
9.3080 +\\000\000\
9.3081 +\\000\000\
9.3082 +\\000\000\
9.3083 +\\000\000\
9.3084 +\\000\000\
9.3085 +\\000\000\
9.3086 +\\006\000\033\001\007\000\223\001\008\000\138\001\009\000\031\001\
9.3087 +\\010\000\030\001\011\000\029\001\012\000\028\001\013\000\027\001\
9.3088 +\\014\000\084\000\016\000\026\001\000\000\
9.3089 +\\000\000\
9.3090 +\\000\000\
9.3091 +\\000\000\
9.3092 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3093 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3094 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3095 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3096 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3097 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3098 +\\045\000\112\000\046\000\111\000\051\000\110\000\055\000\109\000\
9.3099 +\\063\000\106\000\065\000\105\000\066\000\225\001\000\000\
9.3100 +\\000\000\
9.3101 +\\000\000\
9.3102 +\\009\000\074\001\047\000\073\001\083\000\226\001\000\000\
9.3103 +\\000\000\
9.3104 +\\009\000\074\001\047\000\073\001\083\000\227\001\000\000\
9.3105 +\\000\000\
9.3106 +\\000\000\
9.3107 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.3108 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3109 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3110 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3111 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3112 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3113 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.3114 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.3115 +\\093\000\229\001\000\000\
9.3116 +\\000\000\
9.3117 +\\000\000\
9.3118 +\\000\000\
9.3119 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.3120 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3121 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3122 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3123 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3124 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3125 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.3126 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.3127 +\\093\000\231\001\000\000\
9.3128 +\\000\000\
9.3129 +\\000\000\
9.3130 +\\000\000\
9.3131 +\\000\000\
9.3132 +\\000\000\
9.3133 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3134 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3135 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3136 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3137 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3138 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3139 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3140 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.3141 +\\118\000\155\000\122\000\154\000\123\000\232\001\000\000\
9.3142 +\\000\000\
9.3143 +\\000\000\
9.3144 +\\000\000\
9.3145 +\\000\000\
9.3146 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3147 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3148 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3149 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3150 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3151 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3152 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3153 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\094\001\
9.3154 +\\118\000\155\000\122\000\154\000\123\000\234\001\000\000\
9.3155 +\\000\000\
9.3156 +\\000\000\
9.3157 +\\000\000\
9.3158 +\\000\000\
9.3159 +\\000\000\
9.3160 +\\000\000\
9.3161 +\\000\000\
9.3162 +\\000\000\
9.3163 +\\000\000\
9.3164 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3165 +\\019\000\083\000\020\000\235\001\022\000\081\000\023\000\080\000\
9.3166 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3167 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3168 +\\032\000\179\000\033\000\070\000\034\000\069\000\000\000\
9.3169 +\\000\000\
9.3170 +\\000\000\
9.3171 +\\000\000\
9.3172 +\\000\000\
9.3173 +\\000\000\
9.3174 +\\009\000\087\000\011\000\140\000\012\000\085\000\014\000\084\000\
9.3175 +\\019\000\083\000\020\000\082\000\022\000\081\000\023\000\080\000\
9.3176 +\\024\000\079\000\025\000\078\000\026\000\077\000\027\000\076\000\
9.3177 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\072\000\
9.3178 +\\032\000\071\000\033\000\070\000\034\000\069\000\035\000\068\000\
9.3179 +\\039\000\067\000\042\000\066\000\043\000\065\000\044\000\064\000\
9.3180 +\\045\000\137\000\046\000\136\000\051\000\135\000\055\000\134\000\
9.3181 +\\077\000\131\000\080\000\130\000\088\000\127\000\092\000\126\000\
9.3182 +\\093\000\125\000\094\000\124\000\095\000\123\000\096\000\122\000\
9.3183 +\\097\000\121\000\098\000\120\000\099\000\236\001\000\000\
9.3184 +\\000\000\
9.3185 +\\000\000\
9.3186 +\\009\000\087\000\011\000\086\000\012\000\085\000\014\000\084\000\
9.3187 +\\019\000\083\000\020\000\183\000\022\000\081\000\023\000\080\000\
9.3188 +\\024\000\079\000\025\000\182\000\026\000\077\000\027\000\181\000\
9.3189 +\\028\000\075\000\029\000\074\000\030\000\073\000\031\000\180\000\
9.3190 +\\032\000\179\000\033\000\070\000\034\000\069\000\036\000\178\000\
9.3191 +\\037\000\177\000\046\000\176\000\049\000\175\000\050\000\174\000\
9.3192 +\\051\000\173\000\052\000\172\000\053\000\171\000\054\000\170\000\
9.3193 +\\056\000\169\000\104\000\166\000\107\000\165\000\108\000\164\000\
9.3194 +\\109\000\163\000\110\000\162\000\111\000\161\000\112\000\160\000\
9.3195 +\\113\000\159\000\115\000\158\000\116\000\157\000\117\000\156\000\
9.3196 +\\118\000\155\000\122\000\154\000\123\000\153\000\124\000\152\000\
9.3197 +\\125\000\151\000\126\000\150\000\127\000\149\000\128\000\148\000\
9.3198 +\\129\000\147\000\130\000\237\001\000\000\
9.3199 +\\000\000\
9.3200 +\\000\000\
9.3201 +\\000\000\
9.3202 +\\000\000\
9.3203 +\\000\000\
9.3204 +\\000\000\
9.3205 +\\000\000\
9.3206 +\\000\000\
9.3207 +\"
9.3208 +val numstates = 498
9.3209 +val numrules = 282
9.3210 +val s = Unsynchronized.ref "" and index = Unsynchronized.ref 0
9.3211 +val string_to_int = fn () =>
9.3212 +let val i = !index
9.3213 +in index := i+2; Char.ord(String.sub(!s,i)) + Char.ord(String.sub(!s,i+1)) * 256
9.3214 +end
9.3215 +val string_to_list = fn s' =>
9.3216 + let val len = String.size s'
9.3217 + fun f () =
9.3218 + if !index < len then string_to_int() :: f()
9.3219 + else nil
9.3220 + in index := 0; s := s'; f ()
9.3221 + end
9.3222 +val string_to_pairlist = fn (conv_key,conv_entry) =>
9.3223 + let fun f () =
9.3224 + case string_to_int()
9.3225 + of 0 => EMPTY
9.3226 + | n => PAIR(conv_key (n-1),conv_entry (string_to_int()),f())
9.3227 + in f
9.3228 + end
9.3229 +val string_to_pairlist_default = fn (conv_key,conv_entry) =>
9.3230 + let val conv_row = string_to_pairlist(conv_key,conv_entry)
9.3231 + in fn () =>
9.3232 + let val default = conv_entry(string_to_int())
9.3233 + val row = conv_row()
9.3234 + in (row,default)
9.3235 + end
9.3236 + end
9.3237 +val string_to_table = fn (convert_row,s') =>
9.3238 + let val len = String.size s'
9.3239 + fun f ()=
9.3240 + if !index < len then convert_row() :: f()
9.3241 + else nil
9.3242 + in (s := s'; index := 0; f ())
9.3243 + end
9.3244 +local
9.3245 + val memo = Array.array(numstates+numrules,ERROR)
9.3246 + val _ =let fun g i=(Array.update(memo,i,REDUCE(i-numstates)); g(i+1))
9.3247 + fun f i =
9.3248 + if i=numstates then g i
9.3249 + else (Array.update(memo,i,SHIFT (STATE i)); f (i+1))
9.3250 + in f 0 handle Subscript => ()
9.3251 + end
9.3252 +in
9.3253 +val entry_to_action = fn 0 => ACCEPT | 1 => ERROR | j => Array.sub(memo,(j-2))
9.3254 +end
9.3255 +val gotoT=Array.fromList(string_to_table(string_to_pairlist(NT,STATE),gotoT))
9.3256 +val actionRows=string_to_table(string_to_pairlist_default(T,entry_to_action),actionRows)
9.3257 +val actionRowNumbers = string_to_list actionRowNumbers
9.3258 +val actionT = let val actionRowLookUp=
9.3259 +let val a=Array.fromList(actionRows) in fn i=>Array.sub(a,i) end
9.3260 +in Array.fromList(map actionRowLookUp actionRowNumbers)
9.3261 +end
9.3262 +in LrTable.mkLrTable {actions=actionT,gotos=gotoT,numRules=numrules,
9.3263 +numStates=numstates,initialState=STATE 0}
9.3264 +end
9.3265 +end
9.3266 +local open Header in
9.3267 +type pos = int
9.3268 +type arg = string
9.3269 +structure MlyValue =
9.3270 +struct
9.3271 +datatype svalue = VOID | ntVOID of unit
9.3272 + | ATOMIC_SYSTEM_WORD of (string) | ATOMIC_DEFINED_WORD of (string)
9.3273 + | DISTINCT_OBJECT of (string) | COMMENT of (string)
9.3274 + | LOWER_WORD of (string) | UPPER_WORD of (string)
9.3275 + | SINGLE_QUOTED of (string) | DOT_DECIMAL of (string)
9.3276 + | UNSIGNED_INTEGER of (string) | SIGNED_INTEGER of (string)
9.3277 + | RATIONAL of (string) | REAL of (string) | tptp of (tptp_problem)
9.3278 + | tptp_file of (tptp_problem) | tptp_input of (tptp_line)
9.3279 + | include_ of (tptp_line) | annotated_formula of (tptp_line)
9.3280 + | thf_annotated of (tptp_line) | tff_annotated of (tptp_line)
9.3281 + | fof_annotated of (tptp_line) | cnf_annotated of (tptp_line)
9.3282 + | formula_role of (role) | thf_formula of (tptp_formula)
9.3283 + | thf_logic_formula of (tptp_formula)
9.3284 + | thf_binary_formula of (tptp_formula)
9.3285 + | thf_binary_pair of (tptp_formula)
9.3286 + | thf_binary_tuple of (tptp_formula)
9.3287 + | thf_or_formula of (tptp_formula)
9.3288 + | thf_and_formula of (tptp_formula)
9.3289 + | thf_apply_formula of (tptp_formula)
9.3290 + | thf_unitary_formula of (tptp_formula)
9.3291 + | thf_quantified_formula of (tptp_formula)
9.3292 + | thf_variable_list of ( ( string * tptp_type option ) list)
9.3293 + | thf_variable of (string*tptp_type option)
9.3294 + | thf_typed_variable of (string*tptp_type option)
9.3295 + | thf_unary_formula of (tptp_formula)
9.3296 + | thf_type_formula of (tptp_formula*tptp_type)
9.3297 + | thf_typeable_formula of (tptp_formula)
9.3298 + | thf_subtype of (tptp_type) | thf_top_level_type of (tptp_type)
9.3299 + | thf_unitary_type of (tptp_type) | thf_binary_type of (tptp_type)
9.3300 + | thf_mapping_type of (tptp_type) | thf_xprod_type of (tptp_type)
9.3301 + | thf_union_type of (tptp_type) | thf_atom of (tptp_formula)
9.3302 + | thf_let of (tptp_formula) | thf_let_list of (tptp_let list)
9.3303 + | thf_defined_var of (tptp_let) | thf_conditional of (tptp_formula)
9.3304 + | thf_sequent of (tptp_formula)
9.3305 + | thf_tuple_list of (tptp_formula list)
9.3306 + | thf_tuple of (tptp_formula list) | tff_formula of (tptp_formula)
9.3307 + | tff_logic_formula of (tptp_formula)
9.3308 + | tff_binary_formula of (tptp_formula)
9.3309 + | tff_binary_nonassoc of (tptp_formula)
9.3310 + | tff_binary_assoc of (tptp_formula)
9.3311 + | tff_or_formula of (tptp_formula)
9.3312 + | tff_and_formula of (tptp_formula)
9.3313 + | tff_unitary_formula of (tptp_formula)
9.3314 + | tff_quantified_formula of (tptp_formula)
9.3315 + | tff_variable_list of ( ( string * tptp_type option ) list)
9.3316 + | tff_variable of (string*tptp_type option)
9.3317 + | tff_typed_variable of (string*tptp_type option)
9.3318 + | tff_unary_formula of (tptp_formula)
9.3319 + | tff_typed_atom of (symbol*tptp_type option)
9.3320 + | tff_untyped_atom of (symbol*tptp_type option)
9.3321 + | tff_top_level_type of (tptp_type)
9.3322 + | tff_unitary_type of (tptp_type) | tff_atomic_type of (tptp_type)
9.3323 + | tff_mapping_type of (tptp_type) | tff_xprod_type of (tptp_type)
9.3324 + | tptp_let of (tptp_formula) | tff_let_list of (tptp_let list)
9.3325 + | tff_defined_var of (tptp_let) | tff_conditional of (tptp_formula)
9.3326 + | tff_sequent of (tptp_formula)
9.3327 + | tff_tuple_list of (tptp_formula list)
9.3328 + | tff_tuple of (tptp_formula list) | fof_formula of (tptp_formula)
9.3329 + | fof_logic_formula of (tptp_formula)
9.3330 + | fof_binary_formula of (tptp_formula)
9.3331 + | fof_binary_nonassoc of (tptp_formula)
9.3332 + | fof_binary_assoc of (tptp_formula)
9.3333 + | fof_or_formula of (tptp_formula)
9.3334 + | fof_and_formula of (tptp_formula)
9.3335 + | fof_unitary_formula of (tptp_formula)
9.3336 + | fof_quantified_formula of (tptp_formula)
9.3337 + | fof_variable_list of (string list)
9.3338 + | fof_unary_formula of (tptp_formula)
9.3339 + | fof_sequent of (tptp_formula) | fof_tuple of (tptp_formula list)
9.3340 + | fof_tuple_list of (tptp_formula list)
9.3341 + | cnf_formula of (tptp_formula) | disjunction of (tptp_formula)
9.3342 + | literal of (tptp_formula) | thf_conn_term of (symbol)
9.3343 + | fol_infix_unary of (tptp_formula)
9.3344 + | thf_quantifier of (quantifier) | thf_pair_connective of (symbol)
9.3345 + | thf_unary_connective of (symbol) | fol_quantifier of (quantifier)
9.3346 + | binary_connective of (symbol) | assoc_connective of (symbol)
9.3347 + | system_type of (string) | defined_type of (tptp_base_type)
9.3348 + | unary_connective of (symbol) | atomic_formula of (tptp_formula)
9.3349 + | plain_atomic_formula of (tptp_formula)
9.3350 + | defined_atomic_formula of (tptp_formula)
9.3351 + | defined_plain_formula of (tptp_formula)
9.3352 + | defined_pred of (string) | defined_prop of (string)
9.3353 + | defined_infix_formula of (tptp_formula)
9.3354 + | defined_infix_pred of (symbol) | infix_inequality of (symbol)
9.3355 + | infix_equality of (symbol)
9.3356 + | system_atomic_formula of (tptp_formula)
9.3357 + | conditional_term of (tptp_term) | function_term of (tptp_term)
9.3358 + | plain_term of (symbol*tptp_term list) | constant of (symbol)
9.3359 + | defined_term of (tptp_term) | defined_atom of (tptp_term)
9.3360 + | defined_atomic_term of (tptp_term)
9.3361 + | defined_plain_term of (symbol*tptp_term list)
9.3362 + | defined_constant of (symbol)
9.3363 + | system_term of (symbol*tptp_term list)
9.3364 + | system_constant of (symbol) | system_functor of (symbol)
9.3365 + | defined_functor of (symbol) | arguments of (tptp_term list)
9.3366 + | term of (tptp_term) | functor_ of (symbol)
9.3367 + | file_name of (string) | useful_info of (general_list)
9.3368 + | general_function of (general_data) | identifier of (string)
9.3369 + | integer of (string) | formula_data of (general_data)
9.3370 + | number of (number_kind*string) | variable_ of (string)
9.3371 + | general_data of (general_data) | atomic_word of (string)
9.3372 + | general_term of (general_term)
9.3373 + | general_terms of (general_term list)
9.3374 + | general_list of (general_list)
9.3375 + | optional_info of (general_term list)
9.3376 + | formula_selection of (string list) | name_list of (string list)
9.3377 + | name of (string) | annotations of (annotation option)
9.3378 +end
9.3379 +type svalue = MlyValue.svalue
9.3380 +type result = tptp_problem
9.3381 +end
9.3382 +structure EC=
9.3383 +struct
9.3384 +open LrTable
9.3385 +infix 5 $$
9.3386 +fun x $$ y = y::x
9.3387 +val is_keyword =
9.3388 +fn _ => false
9.3389 +val preferred_change : (term list * term list) list =
9.3390 +nil
9.3391 +val noShift =
9.3392 +fn (T 37) => true | _ => false
9.3393 +val showTerminal =
9.3394 +fn (T 0) => "AMPERSAND"
9.3395 + | (T 1) => "AT_SIGN"
9.3396 + | (T 2) => "CARET"
9.3397 + | (T 3) => "COLON"
9.3398 + | (T 4) => "COMMA"
9.3399 + | (T 5) => "EQUALS"
9.3400 + | (T 6) => "EXCLAMATION"
9.3401 + | (T 7) => "LET"
9.3402 + | (T 8) => "ARROW"
9.3403 + | (T 9) => "IF"
9.3404 + | (T 10) => "IFF"
9.3405 + | (T 11) => "IMPLIES"
9.3406 + | (T 12) => "INCLUDE"
9.3407 + | (T 13) => "LAMBDA"
9.3408 + | (T 14) => "LBRKT"
9.3409 + | (T 15) => "LPAREN"
9.3410 + | (T 16) => "MAP_TO"
9.3411 + | (T 17) => "MMINUS"
9.3412 + | (T 18) => "NAND"
9.3413 + | (T 19) => "NEQUALS"
9.3414 + | (T 20) => "XOR"
9.3415 + | (T 21) => "NOR"
9.3416 + | (T 22) => "PERIOD"
9.3417 + | (T 23) => "PPLUS"
9.3418 + | (T 24) => "QUESTION"
9.3419 + | (T 25) => "RBRKT"
9.3420 + | (T 26) => "RPAREN"
9.3421 + | (T 27) => "TILDE"
9.3422 + | (T 28) => "TOK_FALSE"
9.3423 + | (T 29) => "TOK_I"
9.3424 + | (T 30) => "TOK_O"
9.3425 + | (T 31) => "TOK_INT"
9.3426 + | (T 32) => "TOK_REAL"
9.3427 + | (T 33) => "TOK_RAT"
9.3428 + | (T 34) => "TOK_TRUE"
9.3429 + | (T 35) => "TOK_TYPE"
9.3430 + | (T 36) => "VLINE"
9.3431 + | (T 37) => "EOF"
9.3432 + | (T 38) => "DTHF"
9.3433 + | (T 39) => "DFOF"
9.3434 + | (T 40) => "DCNF"
9.3435 + | (T 41) => "DFOT"
9.3436 + | (T 42) => "DTFF"
9.3437 + | (T 43) => "REAL"
9.3438 + | (T 44) => "RATIONAL"
9.3439 + | (T 45) => "SIGNED_INTEGER"
9.3440 + | (T 46) => "UNSIGNED_INTEGER"
9.3441 + | (T 47) => "DOT_DECIMAL"
9.3442 + | (T 48) => "SINGLE_QUOTED"
9.3443 + | (T 49) => "UPPER_WORD"
9.3444 + | (T 50) => "LOWER_WORD"
9.3445 + | (T 51) => "COMMENT"
9.3446 + | (T 52) => "DISTINCT_OBJECT"
9.3447 + | (T 53) => "DUD"
9.3448 + | (T 54) => "INDEF_CHOICE"
9.3449 + | (T 55) => "DEFIN_CHOICE"
9.3450 + | (T 56) => "OPERATOR_FORALL"
9.3451 + | (T 57) => "OPERATOR_EXISTS"
9.3452 + | (T 58) => "PLUS"
9.3453 + | (T 59) => "TIMES"
9.3454 + | (T 60) => "GENTZEN_ARROW"
9.3455 + | (T 61) => "DEP_SUM"
9.3456 + | (T 62) => "DEP_PROD"
9.3457 + | (T 63) => "ATOMIC_DEFINED_WORD"
9.3458 + | (T 64) => "ATOMIC_SYSTEM_WORD"
9.3459 + | (T 65) => "SUBTYPE"
9.3460 + | (T 66) => "LET_TERM"
9.3461 + | (T 67) => "THF"
9.3462 + | (T 68) => "TFF"
9.3463 + | (T 69) => "FOF"
9.3464 + | (T 70) => "CNF"
9.3465 + | (T 71) => "ITE_F"
9.3466 + | (T 72) => "ITE_T"
9.3467 + | _ => "bogus-term"
9.3468 +local open Header in
9.3469 +val errtermvalue=
9.3470 +fn _ => MlyValue.VOID
9.3471 +end
9.3472 +val terms : term list = nil
9.3473 + $$ (T 72) $$ (T 71) $$ (T 70) $$ (T 69) $$ (T 68) $$ (T 67) $$ (T 66)
9.3474 + $$ (T 65) $$ (T 62) $$ (T 61) $$ (T 60) $$ (T 59) $$ (T 58) $$ (T 57)
9.3475 + $$ (T 56) $$ (T 55) $$ (T 54) $$ (T 53) $$ (T 42) $$ (T 41) $$ (T 40)
9.3476 + $$ (T 39) $$ (T 38) $$ (T 37) $$ (T 36) $$ (T 35) $$ (T 34) $$ (T 33)
9.3477 + $$ (T 32) $$ (T 31) $$ (T 30) $$ (T 29) $$ (T 28) $$ (T 27) $$ (T 26)
9.3478 + $$ (T 25) $$ (T 24) $$ (T 23) $$ (T 22) $$ (T 21) $$ (T 20) $$ (T 19)
9.3479 + $$ (T 18) $$ (T 17) $$ (T 16) $$ (T 15) $$ (T 14) $$ (T 13) $$ (T 12)
9.3480 + $$ (T 11) $$ (T 10) $$ (T 9) $$ (T 8) $$ (T 7) $$ (T 6) $$ (T 5) $$
9.3481 +(T 4) $$ (T 3) $$ (T 2) $$ (T 1) $$ (T 0)end
9.3482 +structure Actions =
9.3483 +struct
9.3484 +exception mlyAction of int
9.3485 +local open Header in
9.3486 +val actions =
9.3487 +fn (i392,defaultPos,stack,
9.3488 + (file_name):arg) =>
9.3489 +case (i392,stack)
9.3490 +of ( 0, ( ( _, ( MlyValue.optional_info optional_info, _,
9.3491 +optional_info1right)) :: ( _, ( MlyValue.general_term general_term, _,
9.3492 + _)) :: ( _, ( _, COMMA1left, _)) :: rest671)) => let val result =
9.3493 +MlyValue.annotations (( SOME (general_term, optional_info) ))
9.3494 + in ( LrTable.NT 0, ( result, COMMA1left, optional_info1right),
9.3495 +rest671)
9.3496 +end
9.3497 +| ( 1, ( rest671)) => let val result = MlyValue.annotations (
9.3498 +( NONE ))
9.3499 + in ( LrTable.NT 0, ( result, defaultPos, defaultPos), rest671)
9.3500 +end
9.3501 +| ( 2, ( ( _, ( MlyValue.useful_info useful_info, _,
9.3502 +useful_info1right)) :: ( _, ( _, COMMA1left, _)) :: rest671)) => let
9.3503 + val result = MlyValue.optional_info (( useful_info ))
9.3504 + in ( LrTable.NT 4, ( result, COMMA1left, useful_info1right), rest671)
9.3505 +
9.3506 +end
9.3507 +| ( 3, ( rest671)) => let val result = MlyValue.optional_info (
9.3508 +( [] ))
9.3509 + in ( LrTable.NT 4, ( result, defaultPos, defaultPos), rest671)
9.3510 +end
9.3511 +| ( 4, ( ( _, ( MlyValue.general_list general_list, general_list1left
9.3512 +, general_list1right)) :: rest671)) => let val result =
9.3513 +MlyValue.useful_info (( general_list ))
9.3514 + in ( LrTable.NT 16, ( result, general_list1left, general_list1right),
9.3515 + rest671)
9.3516 +end
9.3517 +| ( 5, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( MlyValue.general_terms
9.3518 +general_terms, _, _)) :: ( _, ( _, LBRKT1left, _)) :: rest671)) => let
9.3519 + val result = MlyValue.general_list (( general_terms ))
9.3520 + in ( LrTable.NT 5, ( result, LBRKT1left, RBRKT1right), rest671)
9.3521 +end
9.3522 +| ( 6, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( _, LBRKT1left, _)) ::
9.3523 +rest671)) => let val result = MlyValue.general_list (( [] ))
9.3524 + in ( LrTable.NT 5, ( result, LBRKT1left, RBRKT1right), rest671)
9.3525 +end
9.3526 +| ( 7, ( ( _, ( MlyValue.general_terms general_terms, _,
9.3527 +general_terms1right)) :: _ :: ( _, ( MlyValue.general_term
9.3528 +general_term, general_term1left, _)) :: rest671)) => let val result =
9.3529 + MlyValue.general_terms (( general_term :: general_terms ))
9.3530 + in ( LrTable.NT 6, ( result, general_term1left, general_terms1right),
9.3531 + rest671)
9.3532 +end
9.3533 +| ( 8, ( ( _, ( MlyValue.general_term general_term, general_term1left
9.3534 +, general_term1right)) :: rest671)) => let val result =
9.3535 +MlyValue.general_terms (( [general_term] ))
9.3536 + in ( LrTable.NT 6, ( result, general_term1left, general_term1right),
9.3537 +rest671)
9.3538 +end
9.3539 +| ( 9, ( ( _, ( MlyValue.general_data general_data, general_data1left
9.3540 +, general_data1right)) :: rest671)) => let val result =
9.3541 +MlyValue.general_term (( General_Data general_data ))
9.3542 + in ( LrTable.NT 7, ( result, general_data1left, general_data1right),
9.3543 +rest671)
9.3544 +end
9.3545 +| ( 10, ( ( _, ( MlyValue.general_term general_term, _,
9.3546 +general_term1right)) :: _ :: ( _, ( MlyValue.general_data general_data
9.3547 +, general_data1left, _)) :: rest671)) => let val result =
9.3548 +MlyValue.general_term (( General_Term (general_data, general_term) ))
9.3549 + in ( LrTable.NT 7, ( result, general_data1left, general_term1right),
9.3550 +rest671)
9.3551 +end
9.3552 +| ( 11, ( ( _, ( MlyValue.general_list general_list,
9.3553 +general_list1left, general_list1right)) :: rest671)) => let val
9.3554 +result = MlyValue.general_term (( General_List general_list ))
9.3555 + in ( LrTable.NT 7, ( result, general_list1left, general_list1right),
9.3556 +rest671)
9.3557 +end
9.3558 +| ( 12, ( ( _, ( MlyValue.LOWER_WORD LOWER_WORD, LOWER_WORD1left,
9.3559 +LOWER_WORD1right)) :: rest671)) => let val result =
9.3560 +MlyValue.atomic_word (( LOWER_WORD ))
9.3561 + in ( LrTable.NT 8, ( result, LOWER_WORD1left, LOWER_WORD1right),
9.3562 +rest671)
9.3563 +end
9.3564 +| ( 13, ( ( _, ( MlyValue.SINGLE_QUOTED SINGLE_QUOTED,
9.3565 +SINGLE_QUOTED1left, SINGLE_QUOTED1right)) :: rest671)) => let val
9.3566 +result = MlyValue.atomic_word (( SINGLE_QUOTED ))
9.3567 + in ( LrTable.NT 8, ( result, SINGLE_QUOTED1left, SINGLE_QUOTED1right)
9.3568 +, rest671)
9.3569 +end
9.3570 +| ( 14, ( ( _, ( _, THF1left, THF1right)) :: rest671)) => let val
9.3571 +result = MlyValue.atomic_word (( "thf" ))
9.3572 + in ( LrTable.NT 8, ( result, THF1left, THF1right), rest671)
9.3573 +end
9.3574 +| ( 15, ( ( _, ( _, TFF1left, TFF1right)) :: rest671)) => let val
9.3575 +result = MlyValue.atomic_word (( "tff" ))
9.3576 + in ( LrTable.NT 8, ( result, TFF1left, TFF1right), rest671)
9.3577 +end
9.3578 +| ( 16, ( ( _, ( _, FOF1left, FOF1right)) :: rest671)) => let val
9.3579 +result = MlyValue.atomic_word (( "fof" ))
9.3580 + in ( LrTable.NT 8, ( result, FOF1left, FOF1right), rest671)
9.3581 +end
9.3582 +| ( 17, ( ( _, ( _, CNF1left, CNF1right)) :: rest671)) => let val
9.3583 +result = MlyValue.atomic_word (( "cnf" ))
9.3584 + in ( LrTable.NT 8, ( result, CNF1left, CNF1right), rest671)
9.3585 +end
9.3586 +| ( 18, ( ( _, ( _, INCLUDE1left, INCLUDE1right)) :: rest671)) => let
9.3587 + val result = MlyValue.atomic_word (( "include" ))
9.3588 + in ( LrTable.NT 8, ( result, INCLUDE1left, INCLUDE1right), rest671)
9.3589 +
9.3590 +end
9.3591 +| ( 19, ( ( _, ( MlyValue.UPPER_WORD UPPER_WORD, UPPER_WORD1left,
9.3592 +UPPER_WORD1right)) :: rest671)) => let val result =
9.3593 +MlyValue.variable_ (( UPPER_WORD ))
9.3594 + in ( LrTable.NT 10, ( result, UPPER_WORD1left, UPPER_WORD1right),
9.3595 +rest671)
9.3596 +end
9.3597 +| ( 20, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.3598 +MlyValue.general_terms general_terms, _, _)) :: _ :: ( _, (
9.3599 +MlyValue.atomic_word atomic_word, atomic_word1left, _)) :: rest671))
9.3600 + => let val result = MlyValue.general_function (
9.3601 +( Application (atomic_word, general_terms) ))
9.3602 + in ( LrTable.NT 15, ( result, atomic_word1left, RPAREN1right),
9.3603 +rest671)
9.3604 +end
9.3605 +| ( 21, ( ( _, ( MlyValue.atomic_word atomic_word, atomic_word1left,
9.3606 +atomic_word1right)) :: rest671)) => let val result =
9.3607 +MlyValue.general_data (( Atomic_Word atomic_word ))
9.3608 + in ( LrTable.NT 9, ( result, atomic_word1left, atomic_word1right),
9.3609 +rest671)
9.3610 +end
9.3611 +| ( 22, ( ( _, ( MlyValue.general_function general_function,
9.3612 +general_function1left, general_function1right)) :: rest671)) => let
9.3613 + val result = MlyValue.general_data (( general_function ))
9.3614 + in ( LrTable.NT 9, ( result, general_function1left,
9.3615 +general_function1right), rest671)
9.3616 +end
9.3617 +| ( 23, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.3618 +variable_1right)) :: rest671)) => let val result =
9.3619 +MlyValue.general_data (( V variable_ ))
9.3620 + in ( LrTable.NT 9, ( result, variable_1left, variable_1right),
9.3621 +rest671)
9.3622 +end
9.3623 +| ( 24, ( ( _, ( MlyValue.number number, number1left, number1right))
9.3624 + :: rest671)) => let val result = MlyValue.general_data (
9.3625 +( Number number ))
9.3626 + in ( LrTable.NT 9, ( result, number1left, number1right), rest671)
9.3627 +end
9.3628 +| ( 25, ( ( _, ( MlyValue.DISTINCT_OBJECT DISTINCT_OBJECT,
9.3629 +DISTINCT_OBJECT1left, DISTINCT_OBJECT1right)) :: rest671)) => let val
9.3630 + result = MlyValue.general_data (( Distinct_Object DISTINCT_OBJECT ))
9.3631 + in ( LrTable.NT 9, ( result, DISTINCT_OBJECT1left,
9.3632 +DISTINCT_OBJECT1right), rest671)
9.3633 +end
9.3634 +| ( 26, ( ( _, ( MlyValue.formula_data formula_data,
9.3635 +formula_data1left, formula_data1right)) :: rest671)) => let val
9.3636 +result = MlyValue.general_data (( formula_data ))
9.3637 + in ( LrTable.NT 9, ( result, formula_data1left, formula_data1right),
9.3638 +rest671)
9.3639 +end
9.3640 +| ( 27, ( ( _, ( MlyValue.integer integer, integer1left,
9.3641 +integer1right)) :: rest671)) => let val result = MlyValue.number (
9.3642 +( (Int_num, integer) ))
9.3643 + in ( LrTable.NT 11, ( result, integer1left, integer1right), rest671)
9.3644 +
9.3645 +end
9.3646 +| ( 28, ( ( _, ( MlyValue.REAL REAL, REAL1left, REAL1right)) ::
9.3647 +rest671)) => let val result = MlyValue.number (( (Real_num, REAL) ))
9.3648 + in ( LrTable.NT 11, ( result, REAL1left, REAL1right), rest671)
9.3649 +end
9.3650 +| ( 29, ( ( _, ( MlyValue.RATIONAL RATIONAL, RATIONAL1left,
9.3651 +RATIONAL1right)) :: rest671)) => let val result = MlyValue.number (
9.3652 +( (Rat_num, RATIONAL) ))
9.3653 + in ( LrTable.NT 11, ( result, RATIONAL1left, RATIONAL1right), rest671
9.3654 +)
9.3655 +end
9.3656 +| ( 30, ( ( _, ( MlyValue.UNSIGNED_INTEGER UNSIGNED_INTEGER,
9.3657 +UNSIGNED_INTEGER1left, UNSIGNED_INTEGER1right)) :: rest671)) => let
9.3658 + val result = MlyValue.integer (( UNSIGNED_INTEGER ))
9.3659 + in ( LrTable.NT 13, ( result, UNSIGNED_INTEGER1left,
9.3660 +UNSIGNED_INTEGER1right), rest671)
9.3661 +end
9.3662 +| ( 31, ( ( _, ( MlyValue.SIGNED_INTEGER SIGNED_INTEGER,
9.3663 +SIGNED_INTEGER1left, SIGNED_INTEGER1right)) :: rest671)) => let val
9.3664 +result = MlyValue.integer (( SIGNED_INTEGER ))
9.3665 + in ( LrTable.NT 13, ( result, SIGNED_INTEGER1left,
9.3666 +SIGNED_INTEGER1right), rest671)
9.3667 +end
9.3668 +| ( 32, ( ( _, ( MlyValue.SINGLE_QUOTED SINGLE_QUOTED,
9.3669 +SINGLE_QUOTED1left, SINGLE_QUOTED1right)) :: rest671)) => let val
9.3670 +result = MlyValue.file_name (( SINGLE_QUOTED ))
9.3671 + in ( LrTable.NT 17, ( result, SINGLE_QUOTED1left, SINGLE_QUOTED1right
9.3672 +), rest671)
9.3673 +end
9.3674 +| ( 33, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.thf_formula
9.3675 +thf_formula, _, _)) :: _ :: ( _, ( _, DTHF1left, _)) :: rest671)) =>
9.3676 + let val result = MlyValue.formula_data (
9.3677 +( Formula_Data (THF, thf_formula) ))
9.3678 + in ( LrTable.NT 12, ( result, DTHF1left, RPAREN1right), rest671)
9.3679 +end
9.3680 +| ( 34, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.tff_formula
9.3681 +tff_formula, _, _)) :: _ :: ( _, ( _, DTFF1left, _)) :: rest671)) =>
9.3682 + let val result = MlyValue.formula_data (
9.3683 +( Formula_Data (TFF, tff_formula) ))
9.3684 + in ( LrTable.NT 12, ( result, DTFF1left, RPAREN1right), rest671)
9.3685 +end
9.3686 +| ( 35, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.fof_formula
9.3687 +fof_formula, _, _)) :: _ :: ( _, ( _, DFOF1left, _)) :: rest671)) =>
9.3688 + let val result = MlyValue.formula_data (
9.3689 +( Formula_Data (FOF, fof_formula) ))
9.3690 + in ( LrTable.NT 12, ( result, DFOF1left, RPAREN1right), rest671)
9.3691 +end
9.3692 +| ( 36, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.cnf_formula
9.3693 +cnf_formula, _, _)) :: _ :: ( _, ( _, DCNF1left, _)) :: rest671)) =>
9.3694 + let val result = MlyValue.formula_data (
9.3695 +( Formula_Data (CNF, cnf_formula) ))
9.3696 + in ( LrTable.NT 12, ( result, DCNF1left, RPAREN1right), rest671)
9.3697 +end
9.3698 +| ( 37, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.term term, _
9.3699 +, _)) :: _ :: ( _, ( _, DFOT1left, _)) :: rest671)) => let val result
9.3700 + = MlyValue.formula_data (( Term_Data term ))
9.3701 + in ( LrTable.NT 12, ( result, DFOT1left, RPAREN1right), rest671)
9.3702 +end
9.3703 +| ( 38, ( ( _, ( MlyValue.ATOMIC_SYSTEM_WORD ATOMIC_SYSTEM_WORD,
9.3704 +ATOMIC_SYSTEM_WORD1left, ATOMIC_SYSTEM_WORD1right)) :: rest671)) =>
9.3705 + let val result = MlyValue.system_type (( ATOMIC_SYSTEM_WORD ))
9.3706 + in ( LrTable.NT 47, ( result, ATOMIC_SYSTEM_WORD1left,
9.3707 +ATOMIC_SYSTEM_WORD1right), rest671)
9.3708 +end
9.3709 +| ( 39, ( ( _, ( MlyValue.ATOMIC_DEFINED_WORD ATOMIC_DEFINED_WORD,
9.3710 +ATOMIC_DEFINED_WORD1left, ATOMIC_DEFINED_WORD1right)) :: rest671)) =>
9.3711 + let val result = MlyValue.defined_type (
9.3712 +(
9.3713 + case ATOMIC_DEFINED_WORD of
9.3714 + "$i" => Type_Ind
9.3715 + | "$o" => Type_Bool
9.3716 + | "$iType" => Type_Ind
9.3717 + | "$oType" => Type_Bool
9.3718 + | "$int" => Type_Int
9.3719 + | "$real" => Type_Real
9.3720 + | "$rat" => Type_Rat
9.3721 + | "$tType" => Type_Type
9.3722 + | thing => raise UNRECOGNISED_SYMBOL ("defined_type", thing)
9.3723 +)
9.3724 +)
9.3725 + in ( LrTable.NT 46, ( result, ATOMIC_DEFINED_WORD1left,
9.3726 +ATOMIC_DEFINED_WORD1right), rest671)
9.3727 +end
9.3728 +| ( 40, ( ( _, ( MlyValue.atomic_word atomic_word, atomic_word1left,
9.3729 +atomic_word1right)) :: rest671)) => let val result =
9.3730 +MlyValue.functor_ (( Uninterpreted atomic_word ))
9.3731 + in ( LrTable.NT 18, ( result, atomic_word1left, atomic_word1right),
9.3732 +rest671)
9.3733 +end
9.3734 +| ( 41, ( ( _, ( MlyValue.term term, term1left, term1right)) ::
9.3735 +rest671)) => let val result = MlyValue.arguments (( [term] ))
9.3736 + in ( LrTable.NT 20, ( result, term1left, term1right), rest671)
9.3737 +end
9.3738 +| ( 42, ( ( _, ( MlyValue.arguments arguments, _, arguments1right))
9.3739 + :: _ :: ( _, ( MlyValue.term term, term1left, _)) :: rest671)) => let
9.3740 + val result = MlyValue.arguments (( term :: arguments ))
9.3741 + in ( LrTable.NT 20, ( result, term1left, arguments1right), rest671)
9.3742 +
9.3743 +end
9.3744 +| ( 43, ( ( _, ( MlyValue.ATOMIC_SYSTEM_WORD ATOMIC_SYSTEM_WORD,
9.3745 +ATOMIC_SYSTEM_WORD1left, ATOMIC_SYSTEM_WORD1right)) :: rest671)) =>
9.3746 + let val result = MlyValue.system_functor (
9.3747 +( System ATOMIC_SYSTEM_WORD ))
9.3748 + in ( LrTable.NT 22, ( result, ATOMIC_SYSTEM_WORD1left,
9.3749 +ATOMIC_SYSTEM_WORD1right), rest671)
9.3750 +end
9.3751 +| ( 44, ( ( _, ( MlyValue.system_functor system_functor,
9.3752 +system_functor1left, system_functor1right)) :: rest671)) => let val
9.3753 +result = MlyValue.system_constant (( system_functor ))
9.3754 + in ( LrTable.NT 23, ( result, system_functor1left,
9.3755 +system_functor1right), rest671)
9.3756 +end
9.3757 +| ( 45, ( ( _, ( MlyValue.system_constant system_constant,
9.3758 +system_constant1left, system_constant1right)) :: rest671)) => let val
9.3759 + result = MlyValue.system_term (( (system_constant, []) ))
9.3760 + in ( LrTable.NT 24, ( result, system_constant1left,
9.3761 +system_constant1right), rest671)
9.3762 +end
9.3763 +| ( 46, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.arguments
9.3764 +arguments, _, _)) :: _ :: ( _, ( MlyValue.system_functor
9.3765 +system_functor, system_functor1left, _)) :: rest671)) => let val
9.3766 +result = MlyValue.system_term (( (system_functor, arguments) ))
9.3767 + in ( LrTable.NT 24, ( result, system_functor1left, RPAREN1right),
9.3768 +rest671)
9.3769 +end
9.3770 +| ( 47, ( ( _, ( MlyValue.ATOMIC_DEFINED_WORD ATOMIC_DEFINED_WORD,
9.3771 +ATOMIC_DEFINED_WORD1left, ATOMIC_DEFINED_WORD1right)) :: rest671)) =>
9.3772 + let val result = MlyValue.defined_functor (
9.3773 +(
9.3774 + case ATOMIC_DEFINED_WORD of
9.3775 + "$sum" => Interpreted_ExtraLogic Sum
9.3776 + | "$difference" => Interpreted_ExtraLogic Difference
9.3777 + | "$product" => Interpreted_ExtraLogic Product
9.3778 + | "$quotient" => Interpreted_ExtraLogic Quotient
9.3779 + | "$quotient_e" => Interpreted_ExtraLogic Quotient_E
9.3780 + | "$quotient_t" => Interpreted_ExtraLogic Quotient_T
9.3781 + | "$quotient_f" => Interpreted_ExtraLogic Quotient_F
9.3782 + | "$remainder_e" => Interpreted_ExtraLogic Remainder_E
9.3783 + | "$remainder_t" => Interpreted_ExtraLogic Remainder_T
9.3784 + | "$remainder_f" => Interpreted_ExtraLogic Remainder_F
9.3785 + | "$floor" => Interpreted_ExtraLogic Floor
9.3786 + | "$ceiling" => Interpreted_ExtraLogic Ceiling
9.3787 + | "$truncate" => Interpreted_ExtraLogic Truncate
9.3788 + | "$round" => Interpreted_ExtraLogic Round
9.3789 + | "$to_int" => Interpreted_ExtraLogic To_Int
9.3790 + | "$to_rat" => Interpreted_ExtraLogic To_Rat
9.3791 + | "$to_real" => Interpreted_ExtraLogic To_Real
9.3792 + | "$uminus" => Interpreted_ExtraLogic UMinus
9.3793 +
9.3794 + | "$i" => TypeSymbol Type_Ind
9.3795 + | "$o" => TypeSymbol Type_Bool
9.3796 + | "$iType" => TypeSymbol Type_Ind
9.3797 + | "$oType" => TypeSymbol Type_Bool
9.3798 + | "$int" => TypeSymbol Type_Int
9.3799 + | "$real" => TypeSymbol Type_Real
9.3800 + | "$rat" => TypeSymbol Type_Rat
9.3801 + | "$tType" => TypeSymbol Type_Type
9.3802 +
9.3803 + | "$true" => Interpreted_Logic True
9.3804 + | "$false" => Interpreted_Logic False
9.3805 +
9.3806 + | "$less" => Interpreted_ExtraLogic Less
9.3807 + | "$lesseq" => Interpreted_ExtraLogic LessEq
9.3808 + | "$greatereq" => Interpreted_ExtraLogic GreaterEq
9.3809 + | "$greater" => Interpreted_ExtraLogic Greater
9.3810 + | "$evaleq" => Interpreted_ExtraLogic EvalEq
9.3811 +
9.3812 + | "$is_int" => Interpreted_ExtraLogic Is_Int
9.3813 + | "$is_rat" => Interpreted_ExtraLogic Is_Rat
9.3814 +
9.3815 + | thing => raise UNRECOGNISED_SYMBOL ("defined_functor", thing)
9.3816 +)
9.3817 +)
9.3818 + in ( LrTable.NT 21, ( result, ATOMIC_DEFINED_WORD1left,
9.3819 +ATOMIC_DEFINED_WORD1right), rest671)
9.3820 +end
9.3821 +| ( 48, ( ( _, ( MlyValue.defined_functor defined_functor,
9.3822 +defined_functor1left, defined_functor1right)) :: rest671)) => let val
9.3823 + result = MlyValue.defined_constant (( defined_functor ))
9.3824 + in ( LrTable.NT 25, ( result, defined_functor1left,
9.3825 +defined_functor1right), rest671)
9.3826 +end
9.3827 +| ( 49, ( ( _, ( MlyValue.defined_constant defined_constant,
9.3828 +defined_constant1left, defined_constant1right)) :: rest671)) => let
9.3829 + val result = MlyValue.defined_plain_term (( (defined_constant, []) )
9.3830 +)
9.3831 + in ( LrTable.NT 26, ( result, defined_constant1left,
9.3832 +defined_constant1right), rest671)
9.3833 +end
9.3834 +| ( 50, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.arguments
9.3835 +arguments, _, _)) :: _ :: ( _, ( MlyValue.defined_functor
9.3836 +defined_functor, defined_functor1left, _)) :: rest671)) => let val
9.3837 +result = MlyValue.defined_plain_term (( (defined_functor, arguments) )
9.3838 +)
9.3839 + in ( LrTable.NT 26, ( result, defined_functor1left, RPAREN1right),
9.3840 +rest671)
9.3841 +end
9.3842 +| ( 51, ( ( _, ( MlyValue.defined_plain_term defined_plain_term,
9.3843 +defined_plain_term1left, defined_plain_term1right)) :: rest671)) =>
9.3844 + let val result = MlyValue.defined_atomic_term (
9.3845 +( Term_Func defined_plain_term ))
9.3846 + in ( LrTable.NT 27, ( result, defined_plain_term1left,
9.3847 +defined_plain_term1right), rest671)
9.3848 +end
9.3849 +| ( 52, ( ( _, ( MlyValue.number number, number1left, number1right))
9.3850 + :: rest671)) => let val result = MlyValue.defined_atom (
9.3851 +( Term_Num number ))
9.3852 + in ( LrTable.NT 28, ( result, number1left, number1right), rest671)
9.3853 +
9.3854 +end
9.3855 +| ( 53, ( ( _, ( MlyValue.DISTINCT_OBJECT DISTINCT_OBJECT,
9.3856 +DISTINCT_OBJECT1left, DISTINCT_OBJECT1right)) :: rest671)) => let val
9.3857 + result = MlyValue.defined_atom (
9.3858 +( Term_Distinct_Object DISTINCT_OBJECT ))
9.3859 + in ( LrTable.NT 28, ( result, DISTINCT_OBJECT1left,
9.3860 +DISTINCT_OBJECT1right), rest671)
9.3861 +end
9.3862 +| ( 54, ( ( _, ( MlyValue.defined_atom defined_atom,
9.3863 +defined_atom1left, defined_atom1right)) :: rest671)) => let val
9.3864 +result = MlyValue.defined_term (( defined_atom ))
9.3865 + in ( LrTable.NT 29, ( result, defined_atom1left, defined_atom1right),
9.3866 + rest671)
9.3867 +end
9.3868 +| ( 55, ( ( _, ( MlyValue.defined_atomic_term defined_atomic_term,
9.3869 +defined_atomic_term1left, defined_atomic_term1right)) :: rest671)) =>
9.3870 + let val result = MlyValue.defined_term (( defined_atomic_term ))
9.3871 + in ( LrTable.NT 29, ( result, defined_atomic_term1left,
9.3872 +defined_atomic_term1right), rest671)
9.3873 +end
9.3874 +| ( 56, ( ( _, ( MlyValue.functor_ functor_, functor_1left,
9.3875 +functor_1right)) :: rest671)) => let val result = MlyValue.constant (
9.3876 +( functor_ ))
9.3877 + in ( LrTable.NT 30, ( result, functor_1left, functor_1right), rest671
9.3878 +)
9.3879 +end
9.3880 +| ( 57, ( ( _, ( MlyValue.constant constant, constant1left,
9.3881 +constant1right)) :: rest671)) => let val result = MlyValue.plain_term
9.3882 + (( (constant, []) ))
9.3883 + in ( LrTable.NT 31, ( result, constant1left, constant1right), rest671
9.3884 +)
9.3885 +end
9.3886 +| ( 58, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.arguments
9.3887 +arguments, _, _)) :: _ :: ( _, ( MlyValue.functor_ functor_,
9.3888 +functor_1left, _)) :: rest671)) => let val result =
9.3889 +MlyValue.plain_term (( (functor_, arguments) ))
9.3890 + in ( LrTable.NT 31, ( result, functor_1left, RPAREN1right), rest671)
9.3891 +
9.3892 +end
9.3893 +| ( 59, ( ( _, ( MlyValue.plain_term plain_term, plain_term1left,
9.3894 +plain_term1right)) :: rest671)) => let val result =
9.3895 +MlyValue.function_term (( Term_Func plain_term ))
9.3896 + in ( LrTable.NT 32, ( result, plain_term1left, plain_term1right),
9.3897 +rest671)
9.3898 +end
9.3899 +| ( 60, ( ( _, ( MlyValue.defined_term defined_term,
9.3900 +defined_term1left, defined_term1right)) :: rest671)) => let val
9.3901 +result = MlyValue.function_term (( defined_term ))
9.3902 + in ( LrTable.NT 32, ( result, defined_term1left, defined_term1right),
9.3903 + rest671)
9.3904 +end
9.3905 +| ( 61, ( ( _, ( MlyValue.system_term system_term, system_term1left,
9.3906 +system_term1right)) :: rest671)) => let val result =
9.3907 +MlyValue.function_term (( Term_Func system_term ))
9.3908 + in ( LrTable.NT 32, ( result, system_term1left, system_term1right),
9.3909 +rest671)
9.3910 +end
9.3911 +| ( 62, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.term term2,
9.3912 + _, _)) :: _ :: ( _, ( MlyValue.term term1, _, _)) :: _ :: ( _, (
9.3913 +MlyValue.tff_logic_formula tff_logic_formula, _, _)) :: _ :: ( _, ( _,
9.3914 + ITE_T1left, _)) :: rest671)) => let val result =
9.3915 +MlyValue.conditional_term (
9.3916 +(
9.3917 + Term_Conditional (tff_logic_formula, term1, term2)
9.3918 +))
9.3919 + in ( LrTable.NT 33, ( result, ITE_T1left, RPAREN1right), rest671)
9.3920 +end
9.3921 +| ( 63, ( ( _, ( MlyValue.function_term function_term,
9.3922 +function_term1left, function_term1right)) :: rest671)) => let val
9.3923 +result = MlyValue.term (( function_term ))
9.3924 + in ( LrTable.NT 19, ( result, function_term1left, function_term1right
9.3925 +), rest671)
9.3926 +end
9.3927 +| ( 64, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.3928 +variable_1right)) :: rest671)) => let val result = MlyValue.term (
9.3929 +( Term_Var variable_ ))
9.3930 + in ( LrTable.NT 19, ( result, variable_1left, variable_1right),
9.3931 +rest671)
9.3932 +end
9.3933 +| ( 65, ( ( _, ( MlyValue.conditional_term conditional_term,
9.3934 +conditional_term1left, conditional_term1right)) :: rest671)) => let
9.3935 + val result = MlyValue.term (( conditional_term ))
9.3936 + in ( LrTable.NT 19, ( result, conditional_term1left,
9.3937 +conditional_term1right), rest671)
9.3938 +end
9.3939 +| ( 66, ( ( _, ( MlyValue.system_term system_term, system_term1left,
9.3940 +system_term1right)) :: rest671)) => let val result =
9.3941 +MlyValue.system_atomic_formula (( Pred system_term ))
9.3942 + in ( LrTable.NT 34, ( result, system_term1left, system_term1right),
9.3943 +rest671)
9.3944 +end
9.3945 +| ( 67, ( ( _, ( _, EQUALS1left, EQUALS1right)) :: rest671)) => let
9.3946 + val result = MlyValue.infix_equality (( Interpreted_Logic Equals ))
9.3947 + in ( LrTable.NT 35, ( result, EQUALS1left, EQUALS1right), rest671)
9.3948 +
9.3949 +end
9.3950 +| ( 68, ( ( _, ( _, NEQUALS1left, NEQUALS1right)) :: rest671)) => let
9.3951 + val result = MlyValue.infix_inequality (
9.3952 +( Interpreted_Logic NEquals ))
9.3953 + in ( LrTable.NT 36, ( result, NEQUALS1left, NEQUALS1right), rest671)
9.3954 +
9.3955 +end
9.3956 +| ( 69, ( ( _, ( MlyValue.infix_equality infix_equality,
9.3957 +infix_equality1left, infix_equality1right)) :: rest671)) => let val
9.3958 +result = MlyValue.defined_infix_pred (( infix_equality ))
9.3959 + in ( LrTable.NT 37, ( result, infix_equality1left,
9.3960 +infix_equality1right), rest671)
9.3961 +end
9.3962 +| ( 70, ( ( _, ( MlyValue.term term2, _, term2right)) :: ( _, (
9.3963 +MlyValue.defined_infix_pred defined_infix_pred, _, _)) :: ( _, (
9.3964 +MlyValue.term term1, term1left, _)) :: rest671)) => let val result =
9.3965 +MlyValue.defined_infix_formula (
9.3966 +(Pred (defined_infix_pred, [term1, term2])))
9.3967 + in ( LrTable.NT 38, ( result, term1left, term2right), rest671)
9.3968 +end
9.3969 +| ( 71, ( ( _, ( MlyValue.ATOMIC_DEFINED_WORD ATOMIC_DEFINED_WORD,
9.3970 +ATOMIC_DEFINED_WORD1left, ATOMIC_DEFINED_WORD1right)) :: rest671)) =>
9.3971 + let val result = MlyValue.defined_prop (
9.3972 +(
9.3973 + case ATOMIC_DEFINED_WORD of
9.3974 + "$true" => "$true"
9.3975 + | "$false" => "$false"
9.3976 + | thing => raise UNRECOGNISED_SYMBOL ("defined_prop", thing)
9.3977 +)
9.3978 +)
9.3979 + in ( LrTable.NT 39, ( result, ATOMIC_DEFINED_WORD1left,
9.3980 +ATOMIC_DEFINED_WORD1right), rest671)
9.3981 +end
9.3982 +| ( 72, ( ( _, ( MlyValue.ATOMIC_DEFINED_WORD ATOMIC_DEFINED_WORD,
9.3983 +ATOMIC_DEFINED_WORD1left, ATOMIC_DEFINED_WORD1right)) :: rest671)) =>
9.3984 + let val result = MlyValue.defined_pred (
9.3985 +(
9.3986 + case ATOMIC_DEFINED_WORD of
9.3987 + "$distinct" => "$distinct"
9.3988 + | "$ite_f" => "$ite_f"
9.3989 + | "$less" => "$less"
9.3990 + | "$lesseq" => "$lesseq"
9.3991 + | "$greater" => "$greater"
9.3992 + | "$greatereq" => "$greatereq"
9.3993 + | "$is_int" => "$is_int"
9.3994 + | "$is_rat" => "$is_rat"
9.3995 + | thing => raise UNRECOGNISED_SYMBOL ("defined_pred", thing)
9.3996 +)
9.3997 +)
9.3998 + in ( LrTable.NT 40, ( result, ATOMIC_DEFINED_WORD1left,
9.3999 +ATOMIC_DEFINED_WORD1right), rest671)
9.4000 +end
9.4001 +| ( 73, ( ( _, ( MlyValue.defined_plain_term defined_plain_term,
9.4002 +defined_plain_term1left, defined_plain_term1right)) :: rest671)) =>
9.4003 + let val result = MlyValue.defined_plain_formula (
9.4004 +( Pred defined_plain_term ))
9.4005 + in ( LrTable.NT 41, ( result, defined_plain_term1left,
9.4006 +defined_plain_term1right), rest671)
9.4007 +end
9.4008 +| ( 74, ( ( _, ( MlyValue.defined_plain_formula defined_plain_formula
9.4009 +, defined_plain_formula1left, defined_plain_formula1right)) :: rest671
9.4010 +)) => let val result = MlyValue.defined_atomic_formula (
9.4011 +( defined_plain_formula ))
9.4012 + in ( LrTable.NT 42, ( result, defined_plain_formula1left,
9.4013 +defined_plain_formula1right), rest671)
9.4014 +end
9.4015 +| ( 75, ( ( _, ( MlyValue.defined_infix_formula defined_infix_formula
9.4016 +, defined_infix_formula1left, defined_infix_formula1right)) :: rest671
9.4017 +)) => let val result = MlyValue.defined_atomic_formula (
9.4018 +( defined_infix_formula ))
9.4019 + in ( LrTable.NT 42, ( result, defined_infix_formula1left,
9.4020 +defined_infix_formula1right), rest671)
9.4021 +end
9.4022 +| ( 76, ( ( _, ( MlyValue.plain_term plain_term, plain_term1left,
9.4023 +plain_term1right)) :: rest671)) => let val result =
9.4024 +MlyValue.plain_atomic_formula (( Pred plain_term ))
9.4025 + in ( LrTable.NT 43, ( result, plain_term1left, plain_term1right),
9.4026 +rest671)
9.4027 +end
9.4028 +| ( 77, ( ( _, ( MlyValue.plain_atomic_formula plain_atomic_formula,
9.4029 +plain_atomic_formula1left, plain_atomic_formula1right)) :: rest671))
9.4030 + => let val result = MlyValue.atomic_formula (
9.4031 +( plain_atomic_formula ))
9.4032 + in ( LrTable.NT 44, ( result, plain_atomic_formula1left,
9.4033 +plain_atomic_formula1right), rest671)
9.4034 +end
9.4035 +| ( 78, ( ( _, ( MlyValue.defined_atomic_formula
9.4036 +defined_atomic_formula, defined_atomic_formula1left,
9.4037 +defined_atomic_formula1right)) :: rest671)) => let val result =
9.4038 +MlyValue.atomic_formula (( defined_atomic_formula ))
9.4039 + in ( LrTable.NT 44, ( result, defined_atomic_formula1left,
9.4040 +defined_atomic_formula1right), rest671)
9.4041 +end
9.4042 +| ( 79, ( ( _, ( MlyValue.system_atomic_formula system_atomic_formula
9.4043 +, system_atomic_formula1left, system_atomic_formula1right)) :: rest671
9.4044 +)) => let val result = MlyValue.atomic_formula (
9.4045 +( system_atomic_formula ))
9.4046 + in ( LrTable.NT 44, ( result, system_atomic_formula1left,
9.4047 +system_atomic_formula1right), rest671)
9.4048 +end
9.4049 +| ( 80, ( ( _, ( _, VLINE1left, VLINE1right)) :: rest671)) => let
9.4050 + val result = MlyValue.assoc_connective (( Interpreted_Logic Or ))
9.4051 + in ( LrTable.NT 48, ( result, VLINE1left, VLINE1right), rest671)
9.4052 +end
9.4053 +| ( 81, ( ( _, ( _, AMPERSAND1left, AMPERSAND1right)) :: rest671)) =>
9.4054 + let val result = MlyValue.assoc_connective (
9.4055 +( Interpreted_Logic And ))
9.4056 + in ( LrTable.NT 48, ( result, AMPERSAND1left, AMPERSAND1right),
9.4057 +rest671)
9.4058 +end
9.4059 +| ( 82, ( ( _, ( _, IFF1left, IFF1right)) :: rest671)) => let val
9.4060 +result = MlyValue.binary_connective (( Interpreted_Logic Iff ))
9.4061 + in ( LrTable.NT 49, ( result, IFF1left, IFF1right), rest671)
9.4062 +end
9.4063 +| ( 83, ( ( _, ( _, IMPLIES1left, IMPLIES1right)) :: rest671)) => let
9.4064 + val result = MlyValue.binary_connective (( Interpreted_Logic If ))
9.4065 + in ( LrTable.NT 49, ( result, IMPLIES1left, IMPLIES1right), rest671)
9.4066 +
9.4067 +end
9.4068 +| ( 84, ( ( _, ( _, IF1left, IF1right)) :: rest671)) => let val
9.4069 +result = MlyValue.binary_connective (( Interpreted_Logic Fi ))
9.4070 + in ( LrTable.NT 49, ( result, IF1left, IF1right), rest671)
9.4071 +end
9.4072 +| ( 85, ( ( _, ( _, XOR1left, XOR1right)) :: rest671)) => let val
9.4073 +result = MlyValue.binary_connective (( Interpreted_Logic Xor ))
9.4074 + in ( LrTable.NT 49, ( result, XOR1left, XOR1right), rest671)
9.4075 +end
9.4076 +| ( 86, ( ( _, ( _, NOR1left, NOR1right)) :: rest671)) => let val
9.4077 +result = MlyValue.binary_connective (( Interpreted_Logic Nor ))
9.4078 + in ( LrTable.NT 49, ( result, NOR1left, NOR1right), rest671)
9.4079 +end
9.4080 +| ( 87, ( ( _, ( _, NAND1left, NAND1right)) :: rest671)) => let val
9.4081 +result = MlyValue.binary_connective (( Interpreted_Logic Nand ))
9.4082 + in ( LrTable.NT 49, ( result, NAND1left, NAND1right), rest671)
9.4083 +end
9.4084 +| ( 88, ( ( _, ( _, EXCLAMATION1left, EXCLAMATION1right)) :: rest671)
9.4085 +) => let val result = MlyValue.fol_quantifier (( Forall ))
9.4086 + in ( LrTable.NT 50, ( result, EXCLAMATION1left, EXCLAMATION1right),
9.4087 +rest671)
9.4088 +end
9.4089 +| ( 89, ( ( _, ( _, QUESTION1left, QUESTION1right)) :: rest671)) =>
9.4090 + let val result = MlyValue.fol_quantifier (( Exists ))
9.4091 + in ( LrTable.NT 50, ( result, QUESTION1left, QUESTION1right), rest671
9.4092 +)
9.4093 +end
9.4094 +| ( 90, ( ( _, ( MlyValue.unary_connective unary_connective,
9.4095 +unary_connective1left, unary_connective1right)) :: rest671)) => let
9.4096 + val result = MlyValue.thf_unary_connective (( unary_connective ))
9.4097 + in ( LrTable.NT 51, ( result, unary_connective1left,
9.4098 +unary_connective1right), rest671)
9.4099 +end
9.4100 +| ( 91, ( ( _, ( _, OPERATOR_FORALL1left, OPERATOR_FORALL1right)) ::
9.4101 +rest671)) => let val result = MlyValue.thf_unary_connective (
9.4102 +( Interpreted_Logic Op_Forall ))
9.4103 + in ( LrTable.NT 51, ( result, OPERATOR_FORALL1left,
9.4104 +OPERATOR_FORALL1right), rest671)
9.4105 +end
9.4106 +| ( 92, ( ( _, ( _, OPERATOR_EXISTS1left, OPERATOR_EXISTS1right)) ::
9.4107 +rest671)) => let val result = MlyValue.thf_unary_connective (
9.4108 +( Interpreted_Logic Op_Exists ))
9.4109 + in ( LrTable.NT 51, ( result, OPERATOR_EXISTS1left,
9.4110 +OPERATOR_EXISTS1right), rest671)
9.4111 +end
9.4112 +| ( 93, ( ( _, ( MlyValue.infix_equality infix_equality,
9.4113 +infix_equality1left, infix_equality1right)) :: rest671)) => let val
9.4114 +result = MlyValue.thf_pair_connective (( infix_equality ))
9.4115 + in ( LrTable.NT 52, ( result, infix_equality1left,
9.4116 +infix_equality1right), rest671)
9.4117 +end
9.4118 +| ( 94, ( ( _, ( MlyValue.infix_inequality infix_inequality,
9.4119 +infix_inequality1left, infix_inequality1right)) :: rest671)) => let
9.4120 + val result = MlyValue.thf_pair_connective (( infix_inequality ))
9.4121 + in ( LrTable.NT 52, ( result, infix_inequality1left,
9.4122 +infix_inequality1right), rest671)
9.4123 +end
9.4124 +| ( 95, ( ( _, ( MlyValue.binary_connective binary_connective,
9.4125 +binary_connective1left, binary_connective1right)) :: rest671)) => let
9.4126 + val result = MlyValue.thf_pair_connective (( binary_connective ))
9.4127 + in ( LrTable.NT 52, ( result, binary_connective1left,
9.4128 +binary_connective1right), rest671)
9.4129 +end
9.4130 +| ( 96, ( ( _, ( MlyValue.fol_quantifier fol_quantifier,
9.4131 +fol_quantifier1left, fol_quantifier1right)) :: rest671)) => let val
9.4132 +result = MlyValue.thf_quantifier (( fol_quantifier ))
9.4133 + in ( LrTable.NT 53, ( result, fol_quantifier1left,
9.4134 +fol_quantifier1right), rest671)
9.4135 +end
9.4136 +| ( 97, ( ( _, ( _, CARET1left, CARET1right)) :: rest671)) => let
9.4137 + val result = MlyValue.thf_quantifier (( Lambda ))
9.4138 + in ( LrTable.NT 53, ( result, CARET1left, CARET1right), rest671)
9.4139 +end
9.4140 +| ( 98, ( ( _, ( _, DEP_PROD1left, DEP_PROD1right)) :: rest671)) =>
9.4141 + let val result = MlyValue.thf_quantifier (( Dep_Prod ))
9.4142 + in ( LrTable.NT 53, ( result, DEP_PROD1left, DEP_PROD1right), rest671
9.4143 +)
9.4144 +end
9.4145 +| ( 99, ( ( _, ( _, DEP_SUM1left, DEP_SUM1right)) :: rest671)) => let
9.4146 + val result = MlyValue.thf_quantifier (( Dep_Sum ))
9.4147 + in ( LrTable.NT 53, ( result, DEP_SUM1left, DEP_SUM1right), rest671)
9.4148 +
9.4149 +end
9.4150 +| ( 100, ( ( _, ( _, INDEF_CHOICE1left, INDEF_CHOICE1right)) ::
9.4151 +rest671)) => let val result = MlyValue.thf_quantifier (( Epsilon ))
9.4152 + in ( LrTable.NT 53, ( result, INDEF_CHOICE1left, INDEF_CHOICE1right),
9.4153 + rest671)
9.4154 +end
9.4155 +| ( 101, ( ( _, ( _, DEFIN_CHOICE1left, DEFIN_CHOICE1right)) ::
9.4156 +rest671)) => let val result = MlyValue.thf_quantifier (( Iota ))
9.4157 + in ( LrTable.NT 53, ( result, DEFIN_CHOICE1left, DEFIN_CHOICE1right),
9.4158 + rest671)
9.4159 +end
9.4160 +| ( 102, ( ( _, ( MlyValue.term term2, _, term2right)) :: ( _, (
9.4161 +MlyValue.infix_inequality infix_inequality, _, _)) :: ( _, (
9.4162 +MlyValue.term term1, term1left, _)) :: rest671)) => let val result =
9.4163 +MlyValue.fol_infix_unary (( Pred (infix_inequality, [term1, term2]) ))
9.4164 + in ( LrTable.NT 54, ( result, term1left, term2right), rest671)
9.4165 +end
9.4166 +| ( 103, ( ( _, ( MlyValue.thf_pair_connective thf_pair_connective,
9.4167 +thf_pair_connective1left, thf_pair_connective1right)) :: rest671)) =>
9.4168 + let val result = MlyValue.thf_conn_term (( thf_pair_connective ))
9.4169 + in ( LrTable.NT 55, ( result, thf_pair_connective1left,
9.4170 +thf_pair_connective1right), rest671)
9.4171 +end
9.4172 +| ( 104, ( ( _, ( MlyValue.assoc_connective assoc_connective,
9.4173 +assoc_connective1left, assoc_connective1right)) :: rest671)) => let
9.4174 + val result = MlyValue.thf_conn_term (( assoc_connective ))
9.4175 + in ( LrTable.NT 55, ( result, assoc_connective1left,
9.4176 +assoc_connective1right), rest671)
9.4177 +end
9.4178 +| ( 105, ( ( _, ( MlyValue.thf_unary_connective thf_unary_connective,
9.4179 + thf_unary_connective1left, thf_unary_connective1right)) :: rest671))
9.4180 + => let val result = MlyValue.thf_conn_term (( thf_unary_connective )
9.4181 +)
9.4182 + in ( LrTable.NT 55, ( result, thf_unary_connective1left,
9.4183 +thf_unary_connective1right), rest671)
9.4184 +end
9.4185 +| ( 106, ( ( _, ( MlyValue.atomic_formula atomic_formula,
9.4186 +atomic_formula1left, atomic_formula1right)) :: rest671)) => let val
9.4187 +result = MlyValue.literal (( atomic_formula ))
9.4188 + in ( LrTable.NT 56, ( result, atomic_formula1left,
9.4189 +atomic_formula1right), rest671)
9.4190 +end
9.4191 +| ( 107, ( ( _, ( MlyValue.atomic_formula atomic_formula, _,
9.4192 +atomic_formula1right)) :: ( _, ( _, TILDE1left, _)) :: rest671)) =>
9.4193 + let val result = MlyValue.literal (
9.4194 +( Fmla (Interpreted_Logic Not, [atomic_formula]) ))
9.4195 + in ( LrTable.NT 56, ( result, TILDE1left, atomic_formula1right),
9.4196 +rest671)
9.4197 +end
9.4198 +| ( 108, ( ( _, ( MlyValue.fol_infix_unary fol_infix_unary,
9.4199 +fol_infix_unary1left, fol_infix_unary1right)) :: rest671)) => let val
9.4200 + result = MlyValue.literal (( fol_infix_unary ))
9.4201 + in ( LrTable.NT 56, ( result, fol_infix_unary1left,
9.4202 +fol_infix_unary1right), rest671)
9.4203 +end
9.4204 +| ( 109, ( ( _, ( MlyValue.literal literal, literal1left,
9.4205 +literal1right)) :: rest671)) => let val result = MlyValue.disjunction
9.4206 + (( literal ))
9.4207 + in ( LrTable.NT 57, ( result, literal1left, literal1right), rest671)
9.4208 +
9.4209 +end
9.4210 +| ( 110, ( ( _, ( MlyValue.literal literal, _, literal1right)) :: _
9.4211 + :: ( _, ( MlyValue.disjunction disjunction, disjunction1left, _)) ::
9.4212 +rest671)) => let val result = MlyValue.disjunction (
9.4213 +( Fmla (Interpreted_Logic Or, [disjunction, literal]) ))
9.4214 + in ( LrTable.NT 57, ( result, disjunction1left, literal1right),
9.4215 +rest671)
9.4216 +end
9.4217 +| ( 111, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.disjunction
9.4218 + disjunction, _, _)) :: ( _, ( _, LPAREN1left, _)) :: rest671)) => let
9.4219 + val result = MlyValue.cnf_formula (( disjunction ))
9.4220 + in ( LrTable.NT 58, ( result, LPAREN1left, RPAREN1right), rest671)
9.4221 +
9.4222 +end
9.4223 +| ( 112, ( ( _, ( MlyValue.disjunction disjunction, disjunction1left,
9.4224 + disjunction1right)) :: rest671)) => let val result =
9.4225 +MlyValue.cnf_formula (( disjunction ))
9.4226 + in ( LrTable.NT 58, ( result, disjunction1left, disjunction1right),
9.4227 +rest671)
9.4228 +end
9.4229 +| ( 113, ( ( _, ( MlyValue.fof_logic_formula fof_logic_formula,
9.4230 +fof_logic_formula1left, fof_logic_formula1right)) :: rest671)) => let
9.4231 + val result = MlyValue.fof_tuple_list (( [fof_logic_formula] ))
9.4232 + in ( LrTable.NT 59, ( result, fof_logic_formula1left,
9.4233 +fof_logic_formula1right), rest671)
9.4234 +end
9.4235 +| ( 114, ( ( _, ( MlyValue.fof_tuple_list fof_tuple_list, _,
9.4236 +fof_tuple_list1right)) :: _ :: ( _, ( MlyValue.fof_logic_formula
9.4237 +fof_logic_formula, fof_logic_formula1left, _)) :: rest671)) => let
9.4238 + val result = MlyValue.fof_tuple_list (
9.4239 +( fof_logic_formula :: fof_tuple_list ))
9.4240 + in ( LrTable.NT 59, ( result, fof_logic_formula1left,
9.4241 +fof_tuple_list1right), rest671)
9.4242 +end
9.4243 +| ( 115, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( _, LBRKT1left, _)) ::
9.4244 + rest671)) => let val result = MlyValue.fof_tuple (( [] ))
9.4245 + in ( LrTable.NT 60, ( result, LBRKT1left, RBRKT1right), rest671)
9.4246 +end
9.4247 +| ( 116, ( ( _, ( _, _, RBRKT1right)) :: ( _, (
9.4248 +MlyValue.fof_tuple_list fof_tuple_list, _, _)) :: ( _, ( _, LBRKT1left
9.4249 +, _)) :: rest671)) => let val result = MlyValue.fof_tuple (
9.4250 +( fof_tuple_list ))
9.4251 + in ( LrTable.NT 60, ( result, LBRKT1left, RBRKT1right), rest671)
9.4252 +end
9.4253 +| ( 117, ( ( _, ( MlyValue.fof_tuple fof_tuple2, _, fof_tuple2right))
9.4254 + :: _ :: ( _, ( MlyValue.fof_tuple fof_tuple1, fof_tuple1left, _)) ::
9.4255 +rest671)) => let val result = MlyValue.fof_sequent (
9.4256 +( Sequent (fof_tuple1, fof_tuple2) ))
9.4257 + in ( LrTable.NT 61, ( result, fof_tuple1left, fof_tuple2right),
9.4258 +rest671)
9.4259 +end
9.4260 +| ( 118, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.fof_sequent
9.4261 + fof_sequent, _, _)) :: ( _, ( _, LPAREN1left, _)) :: rest671)) => let
9.4262 + val result = MlyValue.fof_sequent (( fof_sequent ))
9.4263 + in ( LrTable.NT 61, ( result, LPAREN1left, RPAREN1right), rest671)
9.4264 +
9.4265 +end
9.4266 +| ( 119, ( ( _, ( _, TILDE1left, TILDE1right)) :: rest671)) => let
9.4267 + val result = MlyValue.unary_connective (( Interpreted_Logic Not ))
9.4268 + in ( LrTable.NT 45, ( result, TILDE1left, TILDE1right), rest671)
9.4269 +end
9.4270 +| ( 120, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula, _
9.4271 +, fof_unitary_formula1right)) :: ( _, ( MlyValue.unary_connective
9.4272 +unary_connective, unary_connective1left, _)) :: rest671)) => let val
9.4273 +result = MlyValue.fof_unary_formula (
9.4274 +( Fmla (unary_connective, [fof_unitary_formula]) ))
9.4275 + in ( LrTable.NT 62, ( result, unary_connective1left,
9.4276 +fof_unitary_formula1right), rest671)
9.4277 +end
9.4278 +| ( 121, ( ( _, ( MlyValue.fol_infix_unary fol_infix_unary,
9.4279 +fol_infix_unary1left, fol_infix_unary1right)) :: rest671)) => let val
9.4280 + result = MlyValue.fof_unary_formula (( fol_infix_unary ))
9.4281 + in ( LrTable.NT 62, ( result, fol_infix_unary1left,
9.4282 +fol_infix_unary1right), rest671)
9.4283 +end
9.4284 +| ( 122, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.4285 +variable_1right)) :: rest671)) => let val result =
9.4286 +MlyValue.fof_variable_list (( [variable_] ))
9.4287 + in ( LrTable.NT 63, ( result, variable_1left, variable_1right),
9.4288 +rest671)
9.4289 +end
9.4290 +| ( 123, ( ( _, ( MlyValue.fof_variable_list fof_variable_list, _,
9.4291 +fof_variable_list1right)) :: _ :: ( _, ( MlyValue.variable_ variable_,
9.4292 + variable_1left, _)) :: rest671)) => let val result =
9.4293 +MlyValue.fof_variable_list (( variable_ :: fof_variable_list ))
9.4294 + in ( LrTable.NT 63, ( result, variable_1left, fof_variable_list1right
9.4295 +), rest671)
9.4296 +end
9.4297 +| ( 124, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula, _
9.4298 +, fof_unitary_formula1right)) :: _ :: _ :: ( _, (
9.4299 +MlyValue.fof_variable_list fof_variable_list, _, _)) :: _ :: ( _, (
9.4300 +MlyValue.fol_quantifier fol_quantifier, fol_quantifier1left, _)) ::
9.4301 +rest671)) => let val result = MlyValue.fof_quantified_formula (
9.4302 +(
9.4303 + Quant (fol_quantifier, map (fn v => (v, NONE)) fof_variable_list, fof_unitary_formula)
9.4304 +)
9.4305 +)
9.4306 + in ( LrTable.NT 64, ( result, fol_quantifier1left,
9.4307 +fof_unitary_formula1right), rest671)
9.4308 +end
9.4309 +| ( 125, ( ( _, ( MlyValue.fof_quantified_formula
9.4310 +fof_quantified_formula, fof_quantified_formula1left,
9.4311 +fof_quantified_formula1right)) :: rest671)) => let val result =
9.4312 +MlyValue.fof_unitary_formula (( fof_quantified_formula ))
9.4313 + in ( LrTable.NT 65, ( result, fof_quantified_formula1left,
9.4314 +fof_quantified_formula1right), rest671)
9.4315 +end
9.4316 +| ( 126, ( ( _, ( MlyValue.fof_unary_formula fof_unary_formula,
9.4317 +fof_unary_formula1left, fof_unary_formula1right)) :: rest671)) => let
9.4318 + val result = MlyValue.fof_unitary_formula (( fof_unary_formula ))
9.4319 + in ( LrTable.NT 65, ( result, fof_unary_formula1left,
9.4320 +fof_unary_formula1right), rest671)
9.4321 +end
9.4322 +| ( 127, ( ( _, ( MlyValue.atomic_formula atomic_formula,
9.4323 +atomic_formula1left, atomic_formula1right)) :: rest671)) => let val
9.4324 +result = MlyValue.fof_unitary_formula (( atomic_formula ))
9.4325 + in ( LrTable.NT 65, ( result, atomic_formula1left,
9.4326 +atomic_formula1right), rest671)
9.4327 +end
9.4328 +| ( 128, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4329 +MlyValue.fof_logic_formula fof_logic_formula, _, _)) :: ( _, ( _,
9.4330 +LPAREN1left, _)) :: rest671)) => let val result =
9.4331 +MlyValue.fof_unitary_formula (( fof_logic_formula ))
9.4332 + in ( LrTable.NT 65, ( result, LPAREN1left, RPAREN1right), rest671)
9.4333 +
9.4334 +end
9.4335 +| ( 129, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula2,
9.4336 + _, fof_unitary_formula2right)) :: _ :: ( _, (
9.4337 +MlyValue.fof_unitary_formula fof_unitary_formula1,
9.4338 +fof_unitary_formula1left, _)) :: rest671)) => let val result =
9.4339 +MlyValue.fof_and_formula (
9.4340 +( Fmla (Interpreted_Logic And, [fof_unitary_formula1, fof_unitary_formula2]) )
9.4341 +)
9.4342 + in ( LrTable.NT 66, ( result, fof_unitary_formula1left,
9.4343 +fof_unitary_formula2right), rest671)
9.4344 +end
9.4345 +| ( 130, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula, _
9.4346 +, fof_unitary_formula1right)) :: _ :: ( _, ( MlyValue.fof_and_formula
9.4347 +fof_and_formula, fof_and_formula1left, _)) :: rest671)) => let val
9.4348 +result = MlyValue.fof_and_formula (
9.4349 +( Fmla (Interpreted_Logic And, [fof_and_formula, fof_unitary_formula]) )
9.4350 +)
9.4351 + in ( LrTable.NT 66, ( result, fof_and_formula1left,
9.4352 +fof_unitary_formula1right), rest671)
9.4353 +end
9.4354 +| ( 131, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula2,
9.4355 + _, fof_unitary_formula2right)) :: _ :: ( _, (
9.4356 +MlyValue.fof_unitary_formula fof_unitary_formula1,
9.4357 +fof_unitary_formula1left, _)) :: rest671)) => let val result =
9.4358 +MlyValue.fof_or_formula (
9.4359 +( Fmla (Interpreted_Logic Or, [fof_unitary_formula1, fof_unitary_formula2]) )
9.4360 +)
9.4361 + in ( LrTable.NT 67, ( result, fof_unitary_formula1left,
9.4362 +fof_unitary_formula2right), rest671)
9.4363 +end
9.4364 +| ( 132, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula, _
9.4365 +, fof_unitary_formula1right)) :: _ :: ( _, ( MlyValue.fof_or_formula
9.4366 +fof_or_formula, fof_or_formula1left, _)) :: rest671)) => let val
9.4367 +result = MlyValue.fof_or_formula (
9.4368 +( Fmla (Interpreted_Logic Or, [fof_or_formula, fof_unitary_formula]) )
9.4369 +)
9.4370 + in ( LrTable.NT 67, ( result, fof_or_formula1left,
9.4371 +fof_unitary_formula1right), rest671)
9.4372 +end
9.4373 +| ( 133, ( ( _, ( MlyValue.fof_or_formula fof_or_formula,
9.4374 +fof_or_formula1left, fof_or_formula1right)) :: rest671)) => let val
9.4375 +result = MlyValue.fof_binary_assoc (( fof_or_formula ))
9.4376 + in ( LrTable.NT 68, ( result, fof_or_formula1left,
9.4377 +fof_or_formula1right), rest671)
9.4378 +end
9.4379 +| ( 134, ( ( _, ( MlyValue.fof_and_formula fof_and_formula,
9.4380 +fof_and_formula1left, fof_and_formula1right)) :: rest671)) => let val
9.4381 + result = MlyValue.fof_binary_assoc (( fof_and_formula ))
9.4382 + in ( LrTable.NT 68, ( result, fof_and_formula1left,
9.4383 +fof_and_formula1right), rest671)
9.4384 +end
9.4385 +| ( 135, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula2,
9.4386 + _, fof_unitary_formula2right)) :: ( _, ( MlyValue.binary_connective
9.4387 +binary_connective, _, _)) :: ( _, ( MlyValue.fof_unitary_formula
9.4388 +fof_unitary_formula1, fof_unitary_formula1left, _)) :: rest671)) =>
9.4389 + let val result = MlyValue.fof_binary_nonassoc (
9.4390 +(
9.4391 + Fmla (binary_connective, [fof_unitary_formula1, fof_unitary_formula2] )
9.4392 +)
9.4393 +)
9.4394 + in ( LrTable.NT 69, ( result, fof_unitary_formula1left,
9.4395 +fof_unitary_formula2right), rest671)
9.4396 +end
9.4397 +| ( 136, ( ( _, ( MlyValue.fof_binary_nonassoc fof_binary_nonassoc,
9.4398 +fof_binary_nonassoc1left, fof_binary_nonassoc1right)) :: rest671)) =>
9.4399 + let val result = MlyValue.fof_binary_formula (
9.4400 +( fof_binary_nonassoc ))
9.4401 + in ( LrTable.NT 70, ( result, fof_binary_nonassoc1left,
9.4402 +fof_binary_nonassoc1right), rest671)
9.4403 +end
9.4404 +| ( 137, ( ( _, ( MlyValue.fof_binary_assoc fof_binary_assoc,
9.4405 +fof_binary_assoc1left, fof_binary_assoc1right)) :: rest671)) => let
9.4406 + val result = MlyValue.fof_binary_formula (( fof_binary_assoc ))
9.4407 + in ( LrTable.NT 70, ( result, fof_binary_assoc1left,
9.4408 +fof_binary_assoc1right), rest671)
9.4409 +end
9.4410 +| ( 138, ( ( _, ( MlyValue.fof_binary_formula fof_binary_formula,
9.4411 +fof_binary_formula1left, fof_binary_formula1right)) :: rest671)) =>
9.4412 + let val result = MlyValue.fof_logic_formula (( fof_binary_formula ))
9.4413 + in ( LrTable.NT 71, ( result, fof_binary_formula1left,
9.4414 +fof_binary_formula1right), rest671)
9.4415 +end
9.4416 +| ( 139, ( ( _, ( MlyValue.fof_unitary_formula fof_unitary_formula,
9.4417 +fof_unitary_formula1left, fof_unitary_formula1right)) :: rest671)) =>
9.4418 + let val result = MlyValue.fof_logic_formula (( fof_unitary_formula )
9.4419 +)
9.4420 + in ( LrTable.NT 71, ( result, fof_unitary_formula1left,
9.4421 +fof_unitary_formula1right), rest671)
9.4422 +end
9.4423 +| ( 140, ( ( _, ( MlyValue.fof_logic_formula fof_logic_formula,
9.4424 +fof_logic_formula1left, fof_logic_formula1right)) :: rest671)) => let
9.4425 + val result = MlyValue.fof_formula (( fof_logic_formula ))
9.4426 + in ( LrTable.NT 72, ( result, fof_logic_formula1left,
9.4427 +fof_logic_formula1right), rest671)
9.4428 +end
9.4429 +| ( 141, ( ( _, ( MlyValue.fof_sequent fof_sequent, fof_sequent1left,
9.4430 + fof_sequent1right)) :: rest671)) => let val result =
9.4431 +MlyValue.fof_formula (( fof_sequent ))
9.4432 + in ( LrTable.NT 72, ( result, fof_sequent1left, fof_sequent1right),
9.4433 +rest671)
9.4434 +end
9.4435 +| ( 142, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( _, LBRKT1left, _)) ::
9.4436 + rest671)) => let val result = MlyValue.tff_tuple (( [] ))
9.4437 + in ( LrTable.NT 73, ( result, LBRKT1left, RBRKT1right), rest671)
9.4438 +end
9.4439 +| ( 143, ( ( _, ( _, _, RBRKT1right)) :: ( _, (
9.4440 +MlyValue.tff_tuple_list tff_tuple_list, _, _)) :: ( _, ( _, LBRKT1left
9.4441 +, _)) :: rest671)) => let val result = MlyValue.tff_tuple (
9.4442 +( tff_tuple_list ))
9.4443 + in ( LrTable.NT 73, ( result, LBRKT1left, RBRKT1right), rest671)
9.4444 +end
9.4445 +| ( 144, ( ( _, ( MlyValue.tff_tuple_list tff_tuple_list, _,
9.4446 +tff_tuple_list1right)) :: _ :: ( _, ( MlyValue.tff_logic_formula
9.4447 +tff_logic_formula, tff_logic_formula1left, _)) :: rest671)) => let
9.4448 + val result = MlyValue.tff_tuple_list (
9.4449 +( tff_logic_formula :: tff_tuple_list ))
9.4450 + in ( LrTable.NT 74, ( result, tff_logic_formula1left,
9.4451 +tff_tuple_list1right), rest671)
9.4452 +end
9.4453 +| ( 145, ( ( _, ( MlyValue.tff_logic_formula tff_logic_formula,
9.4454 +tff_logic_formula1left, tff_logic_formula1right)) :: rest671)) => let
9.4455 + val result = MlyValue.tff_tuple_list (( [tff_logic_formula] ))
9.4456 + in ( LrTable.NT 74, ( result, tff_logic_formula1left,
9.4457 +tff_logic_formula1right), rest671)
9.4458 +end
9.4459 +| ( 146, ( ( _, ( MlyValue.tff_tuple tff_tuple2, _, tff_tuple2right))
9.4460 + :: _ :: ( _, ( MlyValue.tff_tuple tff_tuple1, tff_tuple1left, _)) ::
9.4461 +rest671)) => let val result = MlyValue.tff_sequent (
9.4462 +( Sequent (tff_tuple1, tff_tuple2) ))
9.4463 + in ( LrTable.NT 75, ( result, tff_tuple1left, tff_tuple2right),
9.4464 +rest671)
9.4465 +end
9.4466 +| ( 147, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.tff_sequent
9.4467 + tff_sequent, _, _)) :: ( _, ( _, LPAREN1left, _)) :: rest671)) => let
9.4468 + val result = MlyValue.tff_sequent (( tff_sequent ))
9.4469 + in ( LrTable.NT 75, ( result, LPAREN1left, RPAREN1right), rest671)
9.4470 +
9.4471 +end
9.4472 +| ( 148, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4473 +MlyValue.tff_logic_formula tff_logic_formula3, _, _)) :: _ :: ( _, (
9.4474 +MlyValue.tff_logic_formula tff_logic_formula2, _, _)) :: _ :: ( _, (
9.4475 +MlyValue.tff_logic_formula tff_logic_formula1, _, _)) :: _ :: ( _, ( _
9.4476 +, ITE_F1left, _)) :: rest671)) => let val result =
9.4477 +MlyValue.tff_conditional (
9.4478 +(
9.4479 + Conditional (tff_logic_formula1, tff_logic_formula2, tff_logic_formula3)
9.4480 +)
9.4481 +)
9.4482 + in ( LrTable.NT 76, ( result, ITE_F1left, RPAREN1right), rest671)
9.4483 +end
9.4484 +| ( 149, ( ( _, ( MlyValue.tff_logic_formula tff_logic_formula, _,
9.4485 +tff_logic_formula1right)) :: _ :: ( _, ( MlyValue.variable_ variable_,
9.4486 + variable_1left, _)) :: rest671)) => let val result =
9.4487 +MlyValue.tff_defined_var (
9.4488 +( Let_fmla ((variable_, NONE), tff_logic_formula) ))
9.4489 + in ( LrTable.NT 77, ( result, variable_1left, tff_logic_formula1right
9.4490 +), rest671)
9.4491 +end
9.4492 +| ( 150, ( ( _, ( MlyValue.term term, _, term1right)) :: _ :: ( _, (
9.4493 +MlyValue.variable_ variable_, variable_1left, _)) :: rest671)) => let
9.4494 + val result = MlyValue.tff_defined_var (
9.4495 +( Let_term ((variable_, NONE), term) ))
9.4496 + in ( LrTable.NT 77, ( result, variable_1left, term1right), rest671)
9.4497 +
9.4498 +end
9.4499 +| ( 151, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4500 +MlyValue.tff_defined_var tff_defined_var, _, _)) :: ( _, ( _,
9.4501 +LPAREN1left, _)) :: rest671)) => let val result =
9.4502 +MlyValue.tff_defined_var (( tff_defined_var ))
9.4503 + in ( LrTable.NT 77, ( result, LPAREN1left, RPAREN1right), rest671)
9.4504 +
9.4505 +end
9.4506 +| ( 152, ( ( _, ( MlyValue.tff_defined_var tff_defined_var,
9.4507 +tff_defined_var1left, tff_defined_var1right)) :: rest671)) => let val
9.4508 + result = MlyValue.tff_let_list (( [tff_defined_var] ))
9.4509 + in ( LrTable.NT 78, ( result, tff_defined_var1left,
9.4510 +tff_defined_var1right), rest671)
9.4511 +end
9.4512 +| ( 153, ( ( _, ( MlyValue.tff_let_list tff_let_list, _,
9.4513 +tff_let_list1right)) :: _ :: ( _, ( MlyValue.tff_defined_var
9.4514 +tff_defined_var, tff_defined_var1left, _)) :: rest671)) => let val
9.4515 +result = MlyValue.tff_let_list (( tff_defined_var :: tff_let_list ))
9.4516 + in ( LrTable.NT 78, ( result, tff_defined_var1left,
9.4517 +tff_let_list1right), rest671)
9.4518 +end
9.4519 +| ( 154, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula, _
9.4520 +, tff_unitary_formula1right)) :: _ :: _ :: ( _, (
9.4521 +MlyValue.tff_let_list tff_let_list, _, _)) :: _ :: ( _, ( _, LET1left,
9.4522 + _)) :: rest671)) => let val result = MlyValue.tptp_let (
9.4523 +(
9.4524 + Let (tff_let_list, tff_unitary_formula)
9.4525 +))
9.4526 + in ( LrTable.NT 79, ( result, LET1left, tff_unitary_formula1right),
9.4527 +rest671)
9.4528 +end
9.4529 +| ( 155, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type2, _,
9.4530 +tff_atomic_type2right)) :: _ :: ( _, ( MlyValue.tff_atomic_type
9.4531 +tff_atomic_type1, tff_atomic_type1left, _)) :: rest671)) => let val
9.4532 +result = MlyValue.tff_xprod_type (
9.4533 +( Prod_type(tff_atomic_type1, tff_atomic_type2) ))
9.4534 + in ( LrTable.NT 80, ( result, tff_atomic_type1left,
9.4535 +tff_atomic_type2right), rest671)
9.4536 +end
9.4537 +| ( 156, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type, _,
9.4538 +tff_atomic_type1right)) :: _ :: ( _, ( MlyValue.tff_xprod_type
9.4539 +tff_xprod_type, tff_xprod_type1left, _)) :: rest671)) => let val
9.4540 +result = MlyValue.tff_xprod_type (
9.4541 +( Prod_type(tff_xprod_type, tff_atomic_type) ))
9.4542 + in ( LrTable.NT 80, ( result, tff_xprod_type1left,
9.4543 +tff_atomic_type1right), rest671)
9.4544 +end
9.4545 +| ( 157, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4546 +MlyValue.tff_xprod_type tff_xprod_type, _, _)) :: ( _, ( _,
9.4547 +LPAREN1left, _)) :: rest671)) => let val result =
9.4548 +MlyValue.tff_xprod_type (( tff_xprod_type ))
9.4549 + in ( LrTable.NT 80, ( result, LPAREN1left, RPAREN1right), rest671)
9.4550 +
9.4551 +end
9.4552 +| ( 158, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type, _,
9.4553 +tff_atomic_type1right)) :: _ :: ( _, ( MlyValue.tff_unitary_type
9.4554 +tff_unitary_type, tff_unitary_type1left, _)) :: rest671)) => let val
9.4555 +result = MlyValue.tff_mapping_type (
9.4556 +( Fn_type(tff_unitary_type, tff_atomic_type) ))
9.4557 + in ( LrTable.NT 81, ( result, tff_unitary_type1left,
9.4558 +tff_atomic_type1right), rest671)
9.4559 +end
9.4560 +| ( 159, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4561 +MlyValue.tff_mapping_type tff_mapping_type, _, _)) :: ( _, ( _,
9.4562 +LPAREN1left, _)) :: rest671)) => let val result =
9.4563 +MlyValue.tff_mapping_type (( tff_mapping_type ))
9.4564 + in ( LrTable.NT 81, ( result, LPAREN1left, RPAREN1right), rest671)
9.4565 +
9.4566 +end
9.4567 +| ( 160, ( ( _, ( MlyValue.atomic_word atomic_word, atomic_word1left,
9.4568 + atomic_word1right)) :: rest671)) => let val result =
9.4569 +MlyValue.tff_atomic_type (( Atom_type atomic_word ))
9.4570 + in ( LrTable.NT 82, ( result, atomic_word1left, atomic_word1right),
9.4571 +rest671)
9.4572 +end
9.4573 +| ( 161, ( ( _, ( MlyValue.defined_type defined_type,
9.4574 +defined_type1left, defined_type1right)) :: rest671)) => let val
9.4575 +result = MlyValue.tff_atomic_type (( Defined_type defined_type ))
9.4576 + in ( LrTable.NT 82, ( result, defined_type1left, defined_type1right),
9.4577 + rest671)
9.4578 +end
9.4579 +| ( 162, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type,
9.4580 +tff_atomic_type1left, tff_atomic_type1right)) :: rest671)) => let val
9.4581 + result = MlyValue.tff_unitary_type (( tff_atomic_type ))
9.4582 + in ( LrTable.NT 83, ( result, tff_atomic_type1left,
9.4583 +tff_atomic_type1right), rest671)
9.4584 +end
9.4585 +| ( 163, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4586 +MlyValue.tff_xprod_type tff_xprod_type, _, _)) :: ( _, ( _,
9.4587 +LPAREN1left, _)) :: rest671)) => let val result =
9.4588 +MlyValue.tff_unitary_type (( tff_xprod_type ))
9.4589 + in ( LrTable.NT 83, ( result, LPAREN1left, RPAREN1right), rest671)
9.4590 +
9.4591 +end
9.4592 +| ( 164, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type,
9.4593 +tff_atomic_type1left, tff_atomic_type1right)) :: rest671)) => let val
9.4594 + result = MlyValue.tff_top_level_type (( tff_atomic_type ))
9.4595 + in ( LrTable.NT 84, ( result, tff_atomic_type1left,
9.4596 +tff_atomic_type1right), rest671)
9.4597 +end
9.4598 +| ( 165, ( ( _, ( MlyValue.tff_mapping_type tff_mapping_type,
9.4599 +tff_mapping_type1left, tff_mapping_type1right)) :: rest671)) => let
9.4600 + val result = MlyValue.tff_top_level_type (( tff_mapping_type ))
9.4601 + in ( LrTable.NT 84, ( result, tff_mapping_type1left,
9.4602 +tff_mapping_type1right), rest671)
9.4603 +end
9.4604 +| ( 166, ( ( _, ( MlyValue.functor_ functor_, functor_1left,
9.4605 +functor_1right)) :: rest671)) => let val result =
9.4606 +MlyValue.tff_untyped_atom (( (functor_, NONE) ))
9.4607 + in ( LrTable.NT 85, ( result, functor_1left, functor_1right), rest671
9.4608 +)
9.4609 +end
9.4610 +| ( 167, ( ( _, ( MlyValue.system_functor system_functor,
9.4611 +system_functor1left, system_functor1right)) :: rest671)) => let val
9.4612 +result = MlyValue.tff_untyped_atom (( (system_functor, NONE) ))
9.4613 + in ( LrTable.NT 85, ( result, system_functor1left,
9.4614 +system_functor1right), rest671)
9.4615 +end
9.4616 +| ( 168, ( ( _, ( MlyValue.tff_top_level_type tff_top_level_type, _,
9.4617 +tff_top_level_type1right)) :: _ :: ( _, ( MlyValue.tff_untyped_atom
9.4618 +tff_untyped_atom, tff_untyped_atom1left, _)) :: rest671)) => let val
9.4619 +result = MlyValue.tff_typed_atom (
9.4620 +( (fst tff_untyped_atom, SOME tff_top_level_type) ))
9.4621 + in ( LrTable.NT 86, ( result, tff_untyped_atom1left,
9.4622 +tff_top_level_type1right), rest671)
9.4623 +end
9.4624 +| ( 169, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4625 +MlyValue.tff_typed_atom tff_typed_atom, _, _)) :: ( _, ( _,
9.4626 +LPAREN1left, _)) :: rest671)) => let val result =
9.4627 +MlyValue.tff_typed_atom (( tff_typed_atom ))
9.4628 + in ( LrTable.NT 86, ( result, LPAREN1left, RPAREN1right), rest671)
9.4629 +
9.4630 +end
9.4631 +| ( 170, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula, _
9.4632 +, tff_unitary_formula1right)) :: ( _, ( MlyValue.unary_connective
9.4633 +unary_connective, unary_connective1left, _)) :: rest671)) => let val
9.4634 +result = MlyValue.tff_unary_formula (
9.4635 +( Fmla (unary_connective, [tff_unitary_formula]) ))
9.4636 + in ( LrTable.NT 87, ( result, unary_connective1left,
9.4637 +tff_unitary_formula1right), rest671)
9.4638 +end
9.4639 +| ( 171, ( ( _, ( MlyValue.fol_infix_unary fol_infix_unary,
9.4640 +fol_infix_unary1left, fol_infix_unary1right)) :: rest671)) => let val
9.4641 + result = MlyValue.tff_unary_formula (( fol_infix_unary ))
9.4642 + in ( LrTable.NT 87, ( result, fol_infix_unary1left,
9.4643 +fol_infix_unary1right), rest671)
9.4644 +end
9.4645 +| ( 172, ( ( _, ( MlyValue.tff_atomic_type tff_atomic_type, _,
9.4646 +tff_atomic_type1right)) :: _ :: ( _, ( MlyValue.variable_ variable_,
9.4647 +variable_1left, _)) :: rest671)) => let val result =
9.4648 +MlyValue.tff_typed_variable (( (variable_, SOME tff_atomic_type) ))
9.4649 + in ( LrTable.NT 88, ( result, variable_1left, tff_atomic_type1right),
9.4650 + rest671)
9.4651 +end
9.4652 +| ( 173, ( ( _, ( MlyValue.tff_typed_variable tff_typed_variable,
9.4653 +tff_typed_variable1left, tff_typed_variable1right)) :: rest671)) =>
9.4654 + let val result = MlyValue.tff_variable (( tff_typed_variable ))
9.4655 + in ( LrTable.NT 89, ( result, tff_typed_variable1left,
9.4656 +tff_typed_variable1right), rest671)
9.4657 +end
9.4658 +| ( 174, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.4659 +variable_1right)) :: rest671)) => let val result =
9.4660 +MlyValue.tff_variable (( (variable_, NONE) ))
9.4661 + in ( LrTable.NT 89, ( result, variable_1left, variable_1right),
9.4662 +rest671)
9.4663 +end
9.4664 +| ( 175, ( ( _, ( MlyValue.tff_variable tff_variable,
9.4665 +tff_variable1left, tff_variable1right)) :: rest671)) => let val
9.4666 +result = MlyValue.tff_variable_list (( [tff_variable] ))
9.4667 + in ( LrTable.NT 90, ( result, tff_variable1left, tff_variable1right),
9.4668 + rest671)
9.4669 +end
9.4670 +| ( 176, ( ( _, ( MlyValue.tff_variable_list tff_variable_list, _,
9.4671 +tff_variable_list1right)) :: _ :: ( _, ( MlyValue.tff_variable
9.4672 +tff_variable, tff_variable1left, _)) :: rest671)) => let val result =
9.4673 + MlyValue.tff_variable_list (( tff_variable :: tff_variable_list ))
9.4674 + in ( LrTable.NT 90, ( result, tff_variable1left,
9.4675 +tff_variable_list1right), rest671)
9.4676 +end
9.4677 +| ( 177, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula, _
9.4678 +, tff_unitary_formula1right)) :: _ :: _ :: ( _, (
9.4679 +MlyValue.tff_variable_list tff_variable_list, _, _)) :: _ :: ( _, (
9.4680 +MlyValue.fol_quantifier fol_quantifier, fol_quantifier1left, _)) ::
9.4681 +rest671)) => let val result = MlyValue.tff_quantified_formula (
9.4682 +(
9.4683 + Quant (fol_quantifier, tff_variable_list, tff_unitary_formula)
9.4684 +))
9.4685 + in ( LrTable.NT 91, ( result, fol_quantifier1left,
9.4686 +tff_unitary_formula1right), rest671)
9.4687 +end
9.4688 +| ( 178, ( ( _, ( MlyValue.tff_quantified_formula
9.4689 +tff_quantified_formula, tff_quantified_formula1left,
9.4690 +tff_quantified_formula1right)) :: rest671)) => let val result =
9.4691 +MlyValue.tff_unitary_formula (( tff_quantified_formula ))
9.4692 + in ( LrTable.NT 92, ( result, tff_quantified_formula1left,
9.4693 +tff_quantified_formula1right), rest671)
9.4694 +end
9.4695 +| ( 179, ( ( _, ( MlyValue.tff_unary_formula tff_unary_formula,
9.4696 +tff_unary_formula1left, tff_unary_formula1right)) :: rest671)) => let
9.4697 + val result = MlyValue.tff_unitary_formula (( tff_unary_formula ))
9.4698 + in ( LrTable.NT 92, ( result, tff_unary_formula1left,
9.4699 +tff_unary_formula1right), rest671)
9.4700 +end
9.4701 +| ( 180, ( ( _, ( MlyValue.atomic_formula atomic_formula,
9.4702 +atomic_formula1left, atomic_formula1right)) :: rest671)) => let val
9.4703 +result = MlyValue.tff_unitary_formula (( atomic_formula ))
9.4704 + in ( LrTable.NT 92, ( result, atomic_formula1left,
9.4705 +atomic_formula1right), rest671)
9.4706 +end
9.4707 +| ( 181, ( ( _, ( MlyValue.tptp_let tptp_let, tptp_let1left,
9.4708 +tptp_let1right)) :: rest671)) => let val result =
9.4709 +MlyValue.tff_unitary_formula (( tptp_let ))
9.4710 + in ( LrTable.NT 92, ( result, tptp_let1left, tptp_let1right), rest671
9.4711 +)
9.4712 +end
9.4713 +| ( 182, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.4714 +variable_1right)) :: rest671)) => let val result =
9.4715 +MlyValue.tff_unitary_formula (( Pred (Uninterpreted variable_, []) ))
9.4716 + in ( LrTable.NT 92, ( result, variable_1left, variable_1right),
9.4717 +rest671)
9.4718 +end
9.4719 +| ( 183, ( ( _, ( MlyValue.tff_conditional tff_conditional,
9.4720 +tff_conditional1left, tff_conditional1right)) :: rest671)) => let val
9.4721 + result = MlyValue.tff_unitary_formula (( tff_conditional ))
9.4722 + in ( LrTable.NT 92, ( result, tff_conditional1left,
9.4723 +tff_conditional1right), rest671)
9.4724 +end
9.4725 +| ( 184, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4726 +MlyValue.tff_logic_formula tff_logic_formula, _, _)) :: ( _, ( _,
9.4727 +LPAREN1left, _)) :: rest671)) => let val result =
9.4728 +MlyValue.tff_unitary_formula (( tff_logic_formula ))
9.4729 + in ( LrTable.NT 92, ( result, LPAREN1left, RPAREN1right), rest671)
9.4730 +
9.4731 +end
9.4732 +| ( 185, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula2,
9.4733 + _, tff_unitary_formula2right)) :: _ :: ( _, (
9.4734 +MlyValue.tff_unitary_formula tff_unitary_formula1,
9.4735 +tff_unitary_formula1left, _)) :: rest671)) => let val result =
9.4736 +MlyValue.tff_and_formula (
9.4737 +( Fmla (Interpreted_Logic And, [tff_unitary_formula1, tff_unitary_formula2]) )
9.4738 +)
9.4739 + in ( LrTable.NT 93, ( result, tff_unitary_formula1left,
9.4740 +tff_unitary_formula2right), rest671)
9.4741 +end
9.4742 +| ( 186, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula, _
9.4743 +, tff_unitary_formula1right)) :: _ :: ( _, ( MlyValue.tff_and_formula
9.4744 +tff_and_formula, tff_and_formula1left, _)) :: rest671)) => let val
9.4745 +result = MlyValue.tff_and_formula (
9.4746 +( Fmla (Interpreted_Logic And, [tff_and_formula, tff_unitary_formula]) )
9.4747 +)
9.4748 + in ( LrTable.NT 93, ( result, tff_and_formula1left,
9.4749 +tff_unitary_formula1right), rest671)
9.4750 +end
9.4751 +| ( 187, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula2,
9.4752 + _, tff_unitary_formula2right)) :: _ :: ( _, (
9.4753 +MlyValue.tff_unitary_formula tff_unitary_formula1,
9.4754 +tff_unitary_formula1left, _)) :: rest671)) => let val result =
9.4755 +MlyValue.tff_or_formula (
9.4756 +( Fmla (Interpreted_Logic Or, [tff_unitary_formula1, tff_unitary_formula2]) )
9.4757 +)
9.4758 + in ( LrTable.NT 94, ( result, tff_unitary_formula1left,
9.4759 +tff_unitary_formula2right), rest671)
9.4760 +end
9.4761 +| ( 188, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula, _
9.4762 +, tff_unitary_formula1right)) :: _ :: ( _, ( MlyValue.tff_or_formula
9.4763 +tff_or_formula, tff_or_formula1left, _)) :: rest671)) => let val
9.4764 +result = MlyValue.tff_or_formula (
9.4765 +( Fmla (Interpreted_Logic Or, [tff_or_formula, tff_unitary_formula]) )
9.4766 +)
9.4767 + in ( LrTable.NT 94, ( result, tff_or_formula1left,
9.4768 +tff_unitary_formula1right), rest671)
9.4769 +end
9.4770 +| ( 189, ( ( _, ( MlyValue.tff_or_formula tff_or_formula,
9.4771 +tff_or_formula1left, tff_or_formula1right)) :: rest671)) => let val
9.4772 +result = MlyValue.tff_binary_assoc (( tff_or_formula ))
9.4773 + in ( LrTable.NT 95, ( result, tff_or_formula1left,
9.4774 +tff_or_formula1right), rest671)
9.4775 +end
9.4776 +| ( 190, ( ( _, ( MlyValue.tff_and_formula tff_and_formula,
9.4777 +tff_and_formula1left, tff_and_formula1right)) :: rest671)) => let val
9.4778 + result = MlyValue.tff_binary_assoc (( tff_and_formula ))
9.4779 + in ( LrTable.NT 95, ( result, tff_and_formula1left,
9.4780 +tff_and_formula1right), rest671)
9.4781 +end
9.4782 +| ( 191, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula2,
9.4783 + _, tff_unitary_formula2right)) :: ( _, ( MlyValue.binary_connective
9.4784 +binary_connective, _, _)) :: ( _, ( MlyValue.tff_unitary_formula
9.4785 +tff_unitary_formula1, tff_unitary_formula1left, _)) :: rest671)) =>
9.4786 + let val result = MlyValue.tff_binary_nonassoc (
9.4787 +( Fmla (binary_connective, [tff_unitary_formula1, tff_unitary_formula2]) )
9.4788 +)
9.4789 + in ( LrTable.NT 96, ( result, tff_unitary_formula1left,
9.4790 +tff_unitary_formula2right), rest671)
9.4791 +end
9.4792 +| ( 192, ( ( _, ( MlyValue.tff_binary_nonassoc tff_binary_nonassoc,
9.4793 +tff_binary_nonassoc1left, tff_binary_nonassoc1right)) :: rest671)) =>
9.4794 + let val result = MlyValue.tff_binary_formula (
9.4795 +( tff_binary_nonassoc ))
9.4796 + in ( LrTable.NT 97, ( result, tff_binary_nonassoc1left,
9.4797 +tff_binary_nonassoc1right), rest671)
9.4798 +end
9.4799 +| ( 193, ( ( _, ( MlyValue.tff_binary_assoc tff_binary_assoc,
9.4800 +tff_binary_assoc1left, tff_binary_assoc1right)) :: rest671)) => let
9.4801 + val result = MlyValue.tff_binary_formula (( tff_binary_assoc ))
9.4802 + in ( LrTable.NT 97, ( result, tff_binary_assoc1left,
9.4803 +tff_binary_assoc1right), rest671)
9.4804 +end
9.4805 +| ( 194, ( ( _, ( MlyValue.tff_binary_formula tff_binary_formula,
9.4806 +tff_binary_formula1left, tff_binary_formula1right)) :: rest671)) =>
9.4807 + let val result = MlyValue.tff_logic_formula (( tff_binary_formula ))
9.4808 + in ( LrTable.NT 98, ( result, tff_binary_formula1left,
9.4809 +tff_binary_formula1right), rest671)
9.4810 +end
9.4811 +| ( 195, ( ( _, ( MlyValue.tff_unitary_formula tff_unitary_formula,
9.4812 +tff_unitary_formula1left, tff_unitary_formula1right)) :: rest671)) =>
9.4813 + let val result = MlyValue.tff_logic_formula (( tff_unitary_formula )
9.4814 +)
9.4815 + in ( LrTable.NT 98, ( result, tff_unitary_formula1left,
9.4816 +tff_unitary_formula1right), rest671)
9.4817 +end
9.4818 +| ( 196, ( ( _, ( MlyValue.tff_logic_formula tff_logic_formula,
9.4819 +tff_logic_formula1left, tff_logic_formula1right)) :: rest671)) => let
9.4820 + val result = MlyValue.tff_formula (( tff_logic_formula ))
9.4821 + in ( LrTable.NT 99, ( result, tff_logic_formula1left,
9.4822 +tff_logic_formula1right), rest671)
9.4823 +end
9.4824 +| ( 197, ( ( _, ( MlyValue.tff_typed_atom tff_typed_atom,
9.4825 +tff_typed_atom1left, tff_typed_atom1right)) :: rest671)) => let val
9.4826 +result = MlyValue.tff_formula (
9.4827 +( Atom (TFF_Typed_Atom tff_typed_atom) ))
9.4828 + in ( LrTable.NT 99, ( result, tff_typed_atom1left,
9.4829 +tff_typed_atom1right), rest671)
9.4830 +end
9.4831 +| ( 198, ( ( _, ( MlyValue.tff_sequent tff_sequent, tff_sequent1left,
9.4832 + tff_sequent1right)) :: rest671)) => let val result =
9.4833 +MlyValue.tff_formula (( tff_sequent ))
9.4834 + in ( LrTable.NT 99, ( result, tff_sequent1left, tff_sequent1right),
9.4835 +rest671)
9.4836 +end
9.4837 +| ( 199, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( _, LBRKT1left, _)) ::
9.4838 + rest671)) => let val result = MlyValue.thf_tuple (( [] ))
9.4839 + in ( LrTable.NT 100, ( result, LBRKT1left, RBRKT1right), rest671)
9.4840 +end
9.4841 +| ( 200, ( ( _, ( _, _, RBRKT1right)) :: ( _, (
9.4842 +MlyValue.thf_tuple_list thf_tuple_list, _, _)) :: ( _, ( _, LBRKT1left
9.4843 +, _)) :: rest671)) => let val result = MlyValue.thf_tuple (
9.4844 +( thf_tuple_list ))
9.4845 + in ( LrTable.NT 100, ( result, LBRKT1left, RBRKT1right), rest671)
9.4846 +end
9.4847 +| ( 201, ( ( _, ( MlyValue.thf_logic_formula thf_logic_formula,
9.4848 +thf_logic_formula1left, thf_logic_formula1right)) :: rest671)) => let
9.4849 + val result = MlyValue.thf_tuple_list (( [thf_logic_formula] ))
9.4850 + in ( LrTable.NT 101, ( result, thf_logic_formula1left,
9.4851 +thf_logic_formula1right), rest671)
9.4852 +end
9.4853 +| ( 202, ( ( _, ( MlyValue.thf_tuple_list thf_tuple_list, _,
9.4854 +thf_tuple_list1right)) :: _ :: ( _, ( MlyValue.thf_logic_formula
9.4855 +thf_logic_formula, thf_logic_formula1left, _)) :: rest671)) => let
9.4856 + val result = MlyValue.thf_tuple_list (
9.4857 +( thf_logic_formula :: thf_tuple_list ))
9.4858 + in ( LrTable.NT 101, ( result, thf_logic_formula1left,
9.4859 +thf_tuple_list1right), rest671)
9.4860 +end
9.4861 +| ( 203, ( ( _, ( MlyValue.thf_tuple thf_tuple2, _, thf_tuple2right))
9.4862 + :: _ :: ( _, ( MlyValue.thf_tuple thf_tuple1, thf_tuple1left, _)) ::
9.4863 +rest671)) => let val result = MlyValue.thf_sequent (
9.4864 +( Sequent(thf_tuple1, thf_tuple2) ))
9.4865 + in ( LrTable.NT 102, ( result, thf_tuple1left, thf_tuple2right),
9.4866 +rest671)
9.4867 +end
9.4868 +| ( 204, ( ( _, ( _, _, RPAREN1right)) :: ( _, ( MlyValue.thf_sequent
9.4869 + thf_sequent, _, _)) :: ( _, ( _, LPAREN1left, _)) :: rest671)) => let
9.4870 + val result = MlyValue.thf_sequent (( thf_sequent ))
9.4871 + in ( LrTable.NT 102, ( result, LPAREN1left, RPAREN1right), rest671)
9.4872 +
9.4873 +end
9.4874 +| ( 205, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4875 +MlyValue.thf_logic_formula thf_logic_formula3, _, _)) :: _ :: ( _, (
9.4876 +MlyValue.thf_logic_formula thf_logic_formula2, _, _)) :: _ :: ( _, (
9.4877 +MlyValue.thf_logic_formula thf_logic_formula1, _, _)) :: _ :: ( _, ( _
9.4878 +, ITE_F1left, _)) :: rest671)) => let val result =
9.4879 +MlyValue.thf_conditional (
9.4880 +(
9.4881 + Conditional (thf_logic_formula1, thf_logic_formula2, thf_logic_formula3)
9.4882 +)
9.4883 +)
9.4884 + in ( LrTable.NT 103, ( result, ITE_F1left, RPAREN1right), rest671)
9.4885 +
9.4886 +end
9.4887 +| ( 206, ( ( _, ( MlyValue.thf_logic_formula thf_logic_formula, _,
9.4888 +thf_logic_formula1right)) :: _ :: ( _, ( MlyValue.thf_variable
9.4889 +thf_variable, thf_variable1left, _)) :: rest671)) => let val result =
9.4890 + MlyValue.thf_defined_var (
9.4891 +( Let_fmla (thf_variable, thf_logic_formula) ))
9.4892 + in ( LrTable.NT 104, ( result, thf_variable1left,
9.4893 +thf_logic_formula1right), rest671)
9.4894 +end
9.4895 +| ( 207, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.4896 +MlyValue.thf_defined_var thf_defined_var, _, _)) :: ( _, ( _,
9.4897 +LPAREN1left, _)) :: rest671)) => let val result =
9.4898 +MlyValue.thf_defined_var (( thf_defined_var ))
9.4899 + in ( LrTable.NT 104, ( result, LPAREN1left, RPAREN1right), rest671)
9.4900 +
9.4901 +end
9.4902 +| ( 208, ( ( _, ( MlyValue.thf_defined_var thf_defined_var,
9.4903 +thf_defined_var1left, thf_defined_var1right)) :: rest671)) => let val
9.4904 + result = MlyValue.thf_let_list (( [thf_defined_var] ))
9.4905 + in ( LrTable.NT 105, ( result, thf_defined_var1left,
9.4906 +thf_defined_var1right), rest671)
9.4907 +end
9.4908 +| ( 209, ( ( _, ( MlyValue.thf_let_list thf_let_list, _,
9.4909 +thf_let_list1right)) :: _ :: ( _, ( MlyValue.thf_defined_var
9.4910 +thf_defined_var, thf_defined_var1left, _)) :: rest671)) => let val
9.4911 +result = MlyValue.thf_let_list (( thf_defined_var :: thf_let_list ))
9.4912 + in ( LrTable.NT 105, ( result, thf_defined_var1left,
9.4913 +thf_let_list1right), rest671)
9.4914 +end
9.4915 +| ( 210, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula, _
9.4916 +, thf_unitary_formula1right)) :: _ :: _ :: ( _, (
9.4917 +MlyValue.thf_let_list thf_let_list, _, _)) :: _ :: ( _, ( _, LET1left,
9.4918 + _)) :: rest671)) => let val result = MlyValue.thf_let (
9.4919 +(
9.4920 + Let (thf_let_list, thf_unitary_formula)
9.4921 +))
9.4922 + in ( LrTable.NT 106, ( result, LET1left, thf_unitary_formula1right),
9.4923 +rest671)
9.4924 +end
9.4925 +| ( 211, ( ( _, ( MlyValue.term term, term1left, term1right)) ::
9.4926 +rest671)) => let val result = MlyValue.thf_atom (
9.4927 +( Atom (THF_Atom_term term) ))
9.4928 + in ( LrTable.NT 107, ( result, term1left, term1right), rest671)
9.4929 +end
9.4930 +| ( 212, ( ( _, ( MlyValue.thf_conn_term thf_conn_term,
9.4931 +thf_conn_term1left, thf_conn_term1right)) :: rest671)) => let val
9.4932 +result = MlyValue.thf_atom (
9.4933 +( Atom (THF_Atom_conn_term thf_conn_term) ))
9.4934 + in ( LrTable.NT 107, ( result, thf_conn_term1left,
9.4935 +thf_conn_term1right), rest671)
9.4936 +end
9.4937 +| ( 213, ( ( _, ( MlyValue.thf_unitary_type thf_unitary_type2, _,
9.4938 +thf_unitary_type2right)) :: _ :: ( _, ( MlyValue.thf_unitary_type
9.4939 +thf_unitary_type1, thf_unitary_type1left, _)) :: rest671)) => let val
9.4940 + result = MlyValue.thf_union_type (
9.4941 +( Sum_type(thf_unitary_type1, thf_unitary_type2) ))
9.4942 + in ( LrTable.NT 108, ( result, thf_unitary_type1left,
9.4943 +thf_unitary_type2right), rest671)
9.4944 +end
9.4945 +| ( 214, ( ( _, ( MlyValue.thf_unitary_type thf_unitary_type, _,
9.4946 +thf_unitary_type1right)) :: _ :: ( _, ( MlyValue.thf_union_type
9.4947 +thf_union_type, thf_union_type1left, _)) :: rest671)) => let val
9.4948 +result = MlyValue.thf_union_type (
9.4949 +( Sum_type(thf_union_type, thf_unitary_type) ))
9.4950 + in ( LrTable.NT 108, ( result, thf_union_type1left,
9.4951 +thf_unitary_type1right), rest671)
9.4952 +end
9.4953 +| ( 215, ( ( _, ( MlyValue.thf_unitary_type thf_unitary_type2, _,
9.4954 +thf_unitary_type2right)) :: _ :: ( _, ( MlyValue.thf_unitary_type
9.4955 +thf_unitary_type1, thf_unitary_type1left, _)) :: rest671)) => let val
9.4956 + result = MlyValue.thf_xprod_type (
9.4957 +( Prod_type(thf_unitary_type1, thf_unitary_type2) ))
9.4958 + in ( LrTable.NT 109, ( result, thf_unitary_type1left,
9.4959 +thf_unitary_type2right), rest671)
9.4960 +end
9.4961 +| ( 216, ( ( _, ( MlyValue.thf_unitary_type thf_unitary_type, _,
9.4962 +thf_unitary_type1right)) :: _ :: ( _, ( MlyValue.thf_xprod_type
9.4963 +thf_xprod_type, thf_xprod_type1left, _)) :: rest671)) => let val
9.4964 +result = MlyValue.thf_xprod_type (
9.4965 +( Prod_type(thf_xprod_type, thf_unitary_type) ))
9.4966 + in ( LrTable.NT 109, ( result, thf_xprod_type1left,
9.4967 +thf_unitary_type1right), rest671)
9.4968 +end
9.4969 +| ( 217, ( ( _, ( MlyValue.thf_unitary_type thf_unitary_type2, _,
9.4970 +thf_unitary_type2right)) :: _ :: ( _, ( MlyValue.thf_unitary_type
9.4971 +thf_unitary_type1, thf_unitary_type1left, _)) :: rest671)) => let val
9.4972 + result = MlyValue.thf_mapping_type (
9.4973 +( Fn_type(thf_unitary_type1, thf_unitary_type2) ))
9.4974 + in ( LrTable.NT 110, ( result, thf_unitary_type1left,
9.4975 +thf_unitary_type2right), rest671)
9.4976 +end
9.4977 +| ( 218, ( ( _, ( MlyValue.thf_mapping_type thf_mapping_type, _,
9.4978 +thf_mapping_type1right)) :: _ :: ( _, ( MlyValue.thf_unitary_type
9.4979 +thf_unitary_type, thf_unitary_type1left, _)) :: rest671)) => let val
9.4980 +result = MlyValue.thf_mapping_type (
9.4981 +( Fn_type(thf_unitary_type, thf_mapping_type) ))
9.4982 + in ( LrTable.NT 110, ( result, thf_unitary_type1left,
9.4983 +thf_mapping_type1right), rest671)
9.4984 +end
9.4985 +| ( 219, ( ( _, ( MlyValue.thf_mapping_type thf_mapping_type,
9.4986 +thf_mapping_type1left, thf_mapping_type1right)) :: rest671)) => let
9.4987 + val result = MlyValue.thf_binary_type (( thf_mapping_type ))
9.4988 + in ( LrTable.NT 111, ( result, thf_mapping_type1left,
9.4989 +thf_mapping_type1right), rest671)
9.4990 +end
9.4991 +| ( 220, ( ( _, ( MlyValue.thf_xprod_type thf_xprod_type,
9.4992 +thf_xprod_type1left, thf_xprod_type1right)) :: rest671)) => let val
9.4993 +result = MlyValue.thf_binary_type (( thf_xprod_type ))
9.4994 + in ( LrTable.NT 111, ( result, thf_xprod_type1left,
9.4995 +thf_xprod_type1right), rest671)
9.4996 +end
9.4997 +| ( 221, ( ( _, ( MlyValue.thf_union_type thf_union_type,
9.4998 +thf_union_type1left, thf_union_type1right)) :: rest671)) => let val
9.4999 +result = MlyValue.thf_binary_type (( thf_union_type ))
9.5000 + in ( LrTable.NT 111, ( result, thf_union_type1left,
9.5001 +thf_union_type1right), rest671)
9.5002 +end
9.5003 +| ( 222, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula,
9.5004 +thf_unitary_formula1left, thf_unitary_formula1right)) :: rest671)) =>
9.5005 + let val result = MlyValue.thf_unitary_type (
9.5006 +( Fmla_type thf_unitary_formula ))
9.5007 + in ( LrTable.NT 112, ( result, thf_unitary_formula1left,
9.5008 +thf_unitary_formula1right), rest671)
9.5009 +end
9.5010 +| ( 223, ( ( _, ( MlyValue.thf_logic_formula thf_logic_formula,
9.5011 +thf_logic_formula1left, thf_logic_formula1right)) :: rest671)) => let
9.5012 + val result = MlyValue.thf_top_level_type (
9.5013 +( Fmla_type thf_logic_formula ))
9.5014 + in ( LrTable.NT 113, ( result, thf_logic_formula1left,
9.5015 +thf_logic_formula1right), rest671)
9.5016 +end
9.5017 +| ( 224, ( ( _, ( MlyValue.constant constant2, _, constant2right)) ::
9.5018 + _ :: ( _, ( MlyValue.constant constant1, constant1left, _)) ::
9.5019 +rest671)) => let val result = MlyValue.thf_subtype (
9.5020 +( Subtype(constant1, constant2) ))
9.5021 + in ( LrTable.NT 114, ( result, constant1left, constant2right),
9.5022 +rest671)
9.5023 +end
9.5024 +| ( 225, ( ( _, ( MlyValue.thf_atom thf_atom, thf_atom1left,
9.5025 +thf_atom1right)) :: rest671)) => let val result =
9.5026 +MlyValue.thf_typeable_formula (( thf_atom ))
9.5027 + in ( LrTable.NT 115, ( result, thf_atom1left, thf_atom1right),
9.5028 +rest671)
9.5029 +end
9.5030 +| ( 226, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.5031 +MlyValue.thf_logic_formula thf_logic_formula, _, _)) :: ( _, ( _,
9.5032 +LPAREN1left, _)) :: rest671)) => let val result =
9.5033 +MlyValue.thf_typeable_formula (( thf_logic_formula ))
9.5034 + in ( LrTable.NT 115, ( result, LPAREN1left, RPAREN1right), rest671)
9.5035 +
9.5036 +end
9.5037 +| ( 227, ( ( _, ( MlyValue.thf_top_level_type thf_top_level_type, _,
9.5038 +thf_top_level_type1right)) :: _ :: ( _, (
9.5039 +MlyValue.thf_typeable_formula thf_typeable_formula,
9.5040 +thf_typeable_formula1left, _)) :: rest671)) => let val result =
9.5041 +MlyValue.thf_type_formula (
9.5042 +( (thf_typeable_formula, thf_top_level_type) ))
9.5043 + in ( LrTable.NT 116, ( result, thf_typeable_formula1left,
9.5044 +thf_top_level_type1right), rest671)
9.5045 +end
9.5046 +| ( 228, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.5047 +MlyValue.thf_logic_formula thf_logic_formula, _, _)) :: _ :: ( _, (
9.5048 +MlyValue.thf_unary_connective thf_unary_connective,
9.5049 +thf_unary_connective1left, _)) :: rest671)) => let val result =
9.5050 +MlyValue.thf_unary_formula (
9.5051 +(
9.5052 + Fmla (thf_unary_connective, [thf_logic_formula])
9.5053 +))
9.5054 + in ( LrTable.NT 117, ( result, thf_unary_connective1left,
9.5055 +RPAREN1right), rest671)
9.5056 +end
9.5057 +| ( 229, ( ( _, ( MlyValue.thf_top_level_type thf_top_level_type, _,
9.5058 +thf_top_level_type1right)) :: _ :: ( _, ( MlyValue.variable_ variable_
9.5059 +, variable_1left, _)) :: rest671)) => let val result =
9.5060 +MlyValue.thf_typed_variable (( (variable_, SOME thf_top_level_type) ))
9.5061 + in ( LrTable.NT 118, ( result, variable_1left,
9.5062 +thf_top_level_type1right), rest671)
9.5063 +end
9.5064 +| ( 230, ( ( _, ( MlyValue.thf_typed_variable thf_typed_variable,
9.5065 +thf_typed_variable1left, thf_typed_variable1right)) :: rest671)) =>
9.5066 + let val result = MlyValue.thf_variable (( thf_typed_variable ))
9.5067 + in ( LrTable.NT 119, ( result, thf_typed_variable1left,
9.5068 +thf_typed_variable1right), rest671)
9.5069 +end
9.5070 +| ( 231, ( ( _, ( MlyValue.variable_ variable_, variable_1left,
9.5071 +variable_1right)) :: rest671)) => let val result =
9.5072 +MlyValue.thf_variable (( (variable_, NONE) ))
9.5073 + in ( LrTable.NT 119, ( result, variable_1left, variable_1right),
9.5074 +rest671)
9.5075 +end
9.5076 +| ( 232, ( ( _, ( MlyValue.thf_variable thf_variable,
9.5077 +thf_variable1left, thf_variable1right)) :: rest671)) => let val
9.5078 +result = MlyValue.thf_variable_list (( [thf_variable] ))
9.5079 + in ( LrTable.NT 120, ( result, thf_variable1left, thf_variable1right)
9.5080 +, rest671)
9.5081 +end
9.5082 +| ( 233, ( ( _, ( MlyValue.thf_variable_list thf_variable_list, _,
9.5083 +thf_variable_list1right)) :: _ :: ( _, ( MlyValue.thf_variable
9.5084 +thf_variable, thf_variable1left, _)) :: rest671)) => let val result =
9.5085 + MlyValue.thf_variable_list (( thf_variable :: thf_variable_list ))
9.5086 + in ( LrTable.NT 120, ( result, thf_variable1left,
9.5087 +thf_variable_list1right), rest671)
9.5088 +end
9.5089 +| ( 234, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula, _
9.5090 +, thf_unitary_formula1right)) :: _ :: _ :: ( _, (
9.5091 +MlyValue.thf_variable_list thf_variable_list, _, _)) :: _ :: ( _, (
9.5092 +MlyValue.thf_quantifier thf_quantifier, thf_quantifier1left, _)) ::
9.5093 +rest671)) => let val result = MlyValue.thf_quantified_formula (
9.5094 +(
9.5095 + Quant (thf_quantifier, thf_variable_list, thf_unitary_formula)
9.5096 +))
9.5097 + in ( LrTable.NT 121, ( result, thf_quantifier1left,
9.5098 +thf_unitary_formula1right), rest671)
9.5099 +end
9.5100 +| ( 235, ( ( _, ( MlyValue.thf_quantified_formula
9.5101 +thf_quantified_formula, thf_quantified_formula1left,
9.5102 +thf_quantified_formula1right)) :: rest671)) => let val result =
9.5103 +MlyValue.thf_unitary_formula (( thf_quantified_formula ))
9.5104 + in ( LrTable.NT 122, ( result, thf_quantified_formula1left,
9.5105 +thf_quantified_formula1right), rest671)
9.5106 +end
9.5107 +| ( 236, ( ( _, ( MlyValue.thf_unary_formula thf_unary_formula,
9.5108 +thf_unary_formula1left, thf_unary_formula1right)) :: rest671)) => let
9.5109 + val result = MlyValue.thf_unitary_formula (( thf_unary_formula ))
9.5110 + in ( LrTable.NT 122, ( result, thf_unary_formula1left,
9.5111 +thf_unary_formula1right), rest671)
9.5112 +end
9.5113 +| ( 237, ( ( _, ( MlyValue.thf_atom thf_atom, thf_atom1left,
9.5114 +thf_atom1right)) :: rest671)) => let val result =
9.5115 +MlyValue.thf_unitary_formula (( thf_atom ))
9.5116 + in ( LrTable.NT 122, ( result, thf_atom1left, thf_atom1right),
9.5117 +rest671)
9.5118 +end
9.5119 +| ( 238, ( ( _, ( MlyValue.thf_let thf_let, thf_let1left,
9.5120 +thf_let1right)) :: rest671)) => let val result =
9.5121 +MlyValue.thf_unitary_formula (( thf_let ))
9.5122 + in ( LrTable.NT 122, ( result, thf_let1left, thf_let1right), rest671)
9.5123 +
9.5124 +end
9.5125 +| ( 239, ( ( _, ( MlyValue.thf_conditional thf_conditional,
9.5126 +thf_conditional1left, thf_conditional1right)) :: rest671)) => let val
9.5127 + result = MlyValue.thf_unitary_formula (( thf_conditional ))
9.5128 + in ( LrTable.NT 122, ( result, thf_conditional1left,
9.5129 +thf_conditional1right), rest671)
9.5130 +end
9.5131 +| ( 240, ( ( _, ( _, _, RPAREN1right)) :: ( _, (
9.5132 +MlyValue.thf_logic_formula thf_logic_formula, _, _)) :: ( _, ( _,
9.5133 +LPAREN1left, _)) :: rest671)) => let val result =
9.5134 +MlyValue.thf_unitary_formula (( thf_logic_formula ))
9.5135 + in ( LrTable.NT 122, ( result, LPAREN1left, RPAREN1right), rest671)
9.5136 +
9.5137 +end
9.5138 +| ( 241, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula2,
9.5139 + _, thf_unitary_formula2right)) :: _ :: ( _, (
9.5140 +MlyValue.thf_unitary_formula thf_unitary_formula1,
9.5141 +thf_unitary_formula1left, _)) :: rest671)) => let val result =
9.5142 +MlyValue.thf_apply_formula (
9.5143 +( Fmla (Interpreted_ExtraLogic Apply, [thf_unitary_formula1, thf_unitary_formula2]) )
9.5144 +)
9.5145 + in ( LrTable.NT 123, ( result, thf_unitary_formula1left,
9.5146 +thf_unitary_formula2right), rest671)
9.5147 +end
9.5148 +| ( 242, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula, _
9.5149 +, thf_unitary_formula1right)) :: _ :: ( _, (
9.5150 +MlyValue.thf_apply_formula thf_apply_formula, thf_apply_formula1left,
9.5151 + _)) :: rest671)) => let val result = MlyValue.thf_apply_formula (
9.5152 +( Fmla (Interpreted_ExtraLogic Apply, [thf_apply_formula, thf_unitary_formula]) )
9.5153 +)
9.5154 + in ( LrTable.NT 123, ( result, thf_apply_formula1left,
9.5155 +thf_unitary_formula1right), rest671)
9.5156 +end
9.5157 +| ( 243, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula2,
9.5158 + _, thf_unitary_formula2right)) :: _ :: ( _, (
9.5159 +MlyValue.thf_unitary_formula thf_unitary_formula1,
9.5160 +thf_unitary_formula1left, _)) :: rest671)) => let val result =
9.5161 +MlyValue.thf_and_formula (
9.5162 +( Fmla (Interpreted_Logic And, [thf_unitary_formula1, thf_unitary_formula2]) )
9.5163 +)
9.5164 + in ( LrTable.NT 124, ( result, thf_unitary_formula1left,
9.5165 +thf_unitary_formula2right), rest671)
9.5166 +end
9.5167 +| ( 244, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula, _
9.5168 +, thf_unitary_formula1right)) :: _ :: ( _, ( MlyValue.thf_and_formula
9.5169 +thf_and_formula, thf_and_formula1left, _)) :: rest671)) => let val
9.5170 +result = MlyValue.thf_and_formula (
9.5171 +( Fmla (Interpreted_Logic And, [thf_and_formula, thf_unitary_formula]) )
9.5172 +)
9.5173 + in ( LrTable.NT 124, ( result, thf_and_formula1left,
9.5174 +thf_unitary_formula1right), rest671)
9.5175 +end
9.5176 +| ( 245, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula2,
9.5177 + _, thf_unitary_formula2right)) :: _ :: ( _, (
9.5178 +MlyValue.thf_unitary_formula thf_unitary_formula1,
9.5179 +thf_unitary_formula1left, _)) :: rest671)) => let val result =
9.5180 +MlyValue.thf_or_formula (
9.5181 +( Fmla (Interpreted_Logic Or, [thf_unitary_formula1, thf_unitary_formula2]) )
9.5182 +)
9.5183 + in ( LrTable.NT 125, ( result, thf_unitary_formula1left,
9.5184 +thf_unitary_formula2right), rest671)
9.5185 +end
9.5186 +| ( 246, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula, _
9.5187 +, thf_unitary_formula1right)) :: _ :: ( _, ( MlyValue.thf_or_formula
9.5188 +thf_or_formula, thf_or_formula1left, _)) :: rest671)) => let val
9.5189 +result = MlyValue.thf_or_formula (
9.5190 +( Fmla (Interpreted_Logic Or, [thf_or_formula, thf_unitary_formula]) )
9.5191 +)
9.5192 + in ( LrTable.NT 125, ( result, thf_or_formula1left,
9.5193 +thf_unitary_formula1right), rest671)
9.5194 +end
9.5195 +| ( 247, ( ( _, ( MlyValue.thf_or_formula thf_or_formula,
9.5196 +thf_or_formula1left, thf_or_formula1right)) :: rest671)) => let val
9.5197 +result = MlyValue.thf_binary_tuple (( thf_or_formula ))
9.5198 + in ( LrTable.NT 126, ( result, thf_or_formula1left,
9.5199 +thf_or_formula1right), rest671)
9.5200 +end
9.5201 +| ( 248, ( ( _, ( MlyValue.thf_and_formula thf_and_formula,
9.5202 +thf_and_formula1left, thf_and_formula1right)) :: rest671)) => let val
9.5203 + result = MlyValue.thf_binary_tuple (( thf_and_formula ))
9.5204 + in ( LrTable.NT 126, ( result, thf_and_formula1left,
9.5205 +thf_and_formula1right), rest671)
9.5206 +end
9.5207 +| ( 249, ( ( _, ( MlyValue.thf_apply_formula thf_apply_formula,
9.5208 +thf_apply_formula1left, thf_apply_formula1right)) :: rest671)) => let
9.5209 + val result = MlyValue.thf_binary_tuple (( thf_apply_formula ))
9.5210 + in ( LrTable.NT 126, ( result, thf_apply_formula1left,
9.5211 +thf_apply_formula1right), rest671)
9.5212 +end
9.5213 +| ( 250, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula2,
9.5214 + _, thf_unitary_formula2right)) :: ( _, ( MlyValue.thf_pair_connective
9.5215 + thf_pair_connective, _, _)) :: ( _, ( MlyValue.thf_unitary_formula
9.5216 +thf_unitary_formula1, thf_unitary_formula1left, _)) :: rest671)) =>
9.5217 + let val result = MlyValue.thf_binary_pair (
9.5218 +(
9.5219 + Fmla (thf_pair_connective, [thf_unitary_formula1, thf_unitary_formula2])
9.5220 +)
9.5221 +)
9.5222 + in ( LrTable.NT 127, ( result, thf_unitary_formula1left,
9.5223 +thf_unitary_formula2right), rest671)
9.5224 +end
9.5225 +| ( 251, ( ( _, ( MlyValue.thf_binary_pair thf_binary_pair,
9.5226 +thf_binary_pair1left, thf_binary_pair1right)) :: rest671)) => let val
9.5227 + result = MlyValue.thf_binary_formula (( thf_binary_pair ))
9.5228 + in ( LrTable.NT 128, ( result, thf_binary_pair1left,
9.5229 +thf_binary_pair1right), rest671)
9.5230 +end
9.5231 +| ( 252, ( ( _, ( MlyValue.thf_binary_tuple thf_binary_tuple,
9.5232 +thf_binary_tuple1left, thf_binary_tuple1right)) :: rest671)) => let
9.5233 + val result = MlyValue.thf_binary_formula (( thf_binary_tuple ))
9.5234 + in ( LrTable.NT 128, ( result, thf_binary_tuple1left,
9.5235 +thf_binary_tuple1right), rest671)
9.5236 +end
9.5237 +| ( 253, ( ( _, ( MlyValue.thf_binary_type thf_binary_type,
9.5238 +thf_binary_type1left, thf_binary_type1right)) :: rest671)) => let val
9.5239 + result = MlyValue.thf_binary_formula (( THF_type thf_binary_type ))
9.5240 + in ( LrTable.NT 128, ( result, thf_binary_type1left,
9.5241 +thf_binary_type1right), rest671)
9.5242 +end
9.5243 +| ( 254, ( ( _, ( MlyValue.thf_binary_formula thf_binary_formula,
9.5244 +thf_binary_formula1left, thf_binary_formula1right)) :: rest671)) =>
9.5245 + let val result = MlyValue.thf_logic_formula (( thf_binary_formula ))
9.5246 + in ( LrTable.NT 129, ( result, thf_binary_formula1left,
9.5247 +thf_binary_formula1right), rest671)
9.5248 +end
9.5249 +| ( 255, ( ( _, ( MlyValue.thf_unitary_formula thf_unitary_formula,
9.5250 +thf_unitary_formula1left, thf_unitary_formula1right)) :: rest671)) =>
9.5251 + let val result = MlyValue.thf_logic_formula (( thf_unitary_formula )
9.5252 +)
9.5253 + in ( LrTable.NT 129, ( result, thf_unitary_formula1left,
9.5254 +thf_unitary_formula1right), rest671)
9.5255 +end
9.5256 +| ( 256, ( ( _, ( MlyValue.thf_type_formula thf_type_formula,
9.5257 +thf_type_formula1left, thf_type_formula1right)) :: rest671)) => let
9.5258 + val result = MlyValue.thf_logic_formula (
9.5259 +( THF_typing thf_type_formula ))
9.5260 + in ( LrTable.NT 129, ( result, thf_type_formula1left,
9.5261 +thf_type_formula1right), rest671)
9.5262 +end
9.5263 +| ( 257, ( ( _, ( MlyValue.thf_subtype thf_subtype, thf_subtype1left,
9.5264 + thf_subtype1right)) :: rest671)) => let val result =
9.5265 +MlyValue.thf_logic_formula (( THF_type thf_subtype ))
9.5266 + in ( LrTable.NT 129, ( result, thf_subtype1left, thf_subtype1right),
9.5267 +rest671)
9.5268 +end
9.5269 +| ( 258, ( ( _, ( MlyValue.thf_logic_formula thf_logic_formula,
9.5270 +thf_logic_formula1left, thf_logic_formula1right)) :: rest671)) => let
9.5271 + val result = MlyValue.thf_formula (( thf_logic_formula ))
9.5272 + in ( LrTable.NT 130, ( result, thf_logic_formula1left,
9.5273 +thf_logic_formula1right), rest671)
9.5274 +end
9.5275 +| ( 259, ( ( _, ( MlyValue.thf_sequent thf_sequent, thf_sequent1left,
9.5276 + thf_sequent1right)) :: rest671)) => let val result =
9.5277 +MlyValue.thf_formula (( thf_sequent ))
9.5278 + in ( LrTable.NT 130, ( result, thf_sequent1left, thf_sequent1right),
9.5279 +rest671)
9.5280 +end
9.5281 +| ( 260, ( ( _, ( MlyValue.LOWER_WORD LOWER_WORD, LOWER_WORD1left,
9.5282 +LOWER_WORD1right)) :: rest671)) => let val result =
9.5283 +MlyValue.formula_role (( classify_role LOWER_WORD ))
9.5284 + in ( LrTable.NT 131, ( result, LOWER_WORD1left, LOWER_WORD1right),
9.5285 +rest671)
9.5286 +end
9.5287 +| ( 261, ( ( _, ( _, _, PERIOD1right)) :: _ :: ( _, (
9.5288 +MlyValue.annotations annotations, _, _)) :: ( _, (
9.5289 +MlyValue.thf_formula thf_formula, _, _)) :: _ :: ( _, (
9.5290 +MlyValue.formula_role formula_role, _, _)) :: _ :: ( _, (
9.5291 +MlyValue.name name, _, _)) :: _ :: ( _, ( _, (THFleft as THF1left),
9.5292 +THFright)) :: rest671)) => let val result = MlyValue.thf_annotated (
9.5293 +(
9.5294 + Annotated_Formula ((file_name, THFleft + 1, THFright + 1),
9.5295 + THF, name, formula_role, thf_formula, annotations)
9.5296 +)
9.5297 +)
9.5298 + in ( LrTable.NT 135, ( result, THF1left, PERIOD1right), rest671)
9.5299 +end
9.5300 +| ( 262, ( ( _, ( _, _, PERIOD1right)) :: _ :: ( _, (
9.5301 +MlyValue.annotations annotations, _, _)) :: ( _, (
9.5302 +MlyValue.tff_formula tff_formula, _, _)) :: _ :: ( _, (
9.5303 +MlyValue.formula_role formula_role, _, _)) :: _ :: ( _, (
9.5304 +MlyValue.name name, _, _)) :: _ :: ( _, ( _, (TFFleft as TFF1left),
9.5305 +TFFright)) :: rest671)) => let val result = MlyValue.tff_annotated (
9.5306 +(
9.5307 + Annotated_Formula ((file_name, TFFleft + 1, TFFright + 1),
9.5308 + TFF, name, formula_role, tff_formula, annotations)
9.5309 +)
9.5310 +)
9.5311 + in ( LrTable.NT 134, ( result, TFF1left, PERIOD1right), rest671)
9.5312 +end
9.5313 +| ( 263, ( ( _, ( _, _, PERIOD1right)) :: _ :: ( _, (
9.5314 +MlyValue.annotations annotations, _, _)) :: ( _, (
9.5315 +MlyValue.fof_formula fof_formula, _, _)) :: _ :: ( _, (
9.5316 +MlyValue.formula_role formula_role, _, _)) :: _ :: ( _, (
9.5317 +MlyValue.name name, _, _)) :: _ :: ( _, ( _, (FOFleft as FOF1left),
9.5318 +FOFright)) :: rest671)) => let val result = MlyValue.fof_annotated (
9.5319 +(
9.5320 + Annotated_Formula ((file_name, FOFleft + 1, FOFright + 1),
9.5321 + FOF, name, formula_role, fof_formula, annotations)
9.5322 +)
9.5323 +)
9.5324 + in ( LrTable.NT 133, ( result, FOF1left, PERIOD1right), rest671)
9.5325 +end
9.5326 +| ( 264, ( ( _, ( _, _, PERIOD1right)) :: _ :: ( _, (
9.5327 +MlyValue.annotations annotations, _, _)) :: ( _, (
9.5328 +MlyValue.cnf_formula cnf_formula, _, _)) :: _ :: ( _, (
9.5329 +MlyValue.formula_role formula_role, _, _)) :: _ :: ( _, (
9.5330 +MlyValue.name name, _, _)) :: _ :: ( _, ( _, (CNFleft as CNF1left),
9.5331 +CNFright)) :: rest671)) => let val result = MlyValue.cnf_annotated (
9.5332 +(
9.5333 + Annotated_Formula ((file_name, CNFleft + 1, CNFright + 1),
9.5334 + CNF, name, formula_role, cnf_formula, annotations)
9.5335 +)
9.5336 +)
9.5337 + in ( LrTable.NT 132, ( result, CNF1left, PERIOD1right), rest671)
9.5338 +end
9.5339 +| ( 265, ( ( _, ( MlyValue.cnf_annotated cnf_annotated,
9.5340 +cnf_annotated1left, cnf_annotated1right)) :: rest671)) => let val
9.5341 +result = MlyValue.annotated_formula (( cnf_annotated ))
9.5342 + in ( LrTable.NT 136, ( result, cnf_annotated1left,
9.5343 +cnf_annotated1right), rest671)
9.5344 +end
9.5345 +| ( 266, ( ( _, ( MlyValue.fof_annotated fof_annotated,
9.5346 +fof_annotated1left, fof_annotated1right)) :: rest671)) => let val
9.5347 +result = MlyValue.annotated_formula (( fof_annotated ))
9.5348 + in ( LrTable.NT 136, ( result, fof_annotated1left,
9.5349 +fof_annotated1right), rest671)
9.5350 +end
9.5351 +| ( 267, ( ( _, ( MlyValue.tff_annotated tff_annotated,
9.5352 +tff_annotated1left, tff_annotated1right)) :: rest671)) => let val
9.5353 +result = MlyValue.annotated_formula (( tff_annotated ))
9.5354 + in ( LrTable.NT 136, ( result, tff_annotated1left,
9.5355 +tff_annotated1right), rest671)
9.5356 +end
9.5357 +| ( 268, ( ( _, ( MlyValue.thf_annotated thf_annotated,
9.5358 +thf_annotated1left, thf_annotated1right)) :: rest671)) => let val
9.5359 +result = MlyValue.annotated_formula (( thf_annotated ))
9.5360 + in ( LrTable.NT 136, ( result, thf_annotated1left,
9.5361 +thf_annotated1right), rest671)
9.5362 +end
9.5363 +| ( 269, ( ( _, ( _, _, PERIOD1right)) :: _ :: ( _, (
9.5364 +MlyValue.formula_selection formula_selection, _, _)) :: ( _, (
9.5365 +MlyValue.file_name file_name, _, _)) :: _ :: ( _, ( _, INCLUDE1left, _
9.5366 +)) :: rest671)) => let val result = MlyValue.include_ (
9.5367 +(
9.5368 + Include (file_name, formula_selection)
9.5369 +))
9.5370 + in ( LrTable.NT 137, ( result, INCLUDE1left, PERIOD1right), rest671)
9.5371 +
9.5372 +end
9.5373 +| ( 270, ( ( _, ( _, _, RBRKT1right)) :: ( _, ( MlyValue.name_list
9.5374 +name_list, _, _)) :: _ :: ( _, ( _, COMMA1left, _)) :: rest671)) =>
9.5375 + let val result = MlyValue.formula_selection (( name_list ))
9.5376 + in ( LrTable.NT 3, ( result, COMMA1left, RBRKT1right), rest671)
9.5377 +end
9.5378 +| ( 271, ( rest671)) => let val result = MlyValue.formula_selection
9.5379 + (( [] ))
9.5380 + in ( LrTable.NT 3, ( result, defaultPos, defaultPos), rest671)
9.5381 +end
9.5382 +| ( 272, ( ( _, ( MlyValue.name_list name_list, _, name_list1right))
9.5383 + :: _ :: ( _, ( MlyValue.name name, name1left, _)) :: rest671)) => let
9.5384 + val result = MlyValue.name_list (( name :: name_list ))
9.5385 + in ( LrTable.NT 2, ( result, name1left, name_list1right), rest671)
9.5386 +
9.5387 +end
9.5388 +| ( 273, ( ( _, ( MlyValue.name name, name1left, name1right)) ::
9.5389 +rest671)) => let val result = MlyValue.name_list (( [name] ))
9.5390 + in ( LrTable.NT 2, ( result, name1left, name1right), rest671)
9.5391 +end
9.5392 +| ( 274, ( ( _, ( MlyValue.atomic_word atomic_word, atomic_word1left,
9.5393 + atomic_word1right)) :: rest671)) => let val result = MlyValue.name (
9.5394 +( atomic_word ))
9.5395 + in ( LrTable.NT 1, ( result, atomic_word1left, atomic_word1right),
9.5396 +rest671)
9.5397 +end
9.5398 +| ( 275, ( ( _, ( MlyValue.integer integer, integer1left,
9.5399 +integer1right)) :: rest671)) => let val result = MlyValue.name (
9.5400 +( integer ))
9.5401 + in ( LrTable.NT 1, ( result, integer1left, integer1right), rest671)
9.5402 +
9.5403 +end
9.5404 +| ( 276, ( ( _, ( MlyValue.annotated_formula annotated_formula,
9.5405 +annotated_formula1left, annotated_formula1right)) :: rest671)) => let
9.5406 + val result = MlyValue.tptp_input (( annotated_formula ))
9.5407 + in ( LrTable.NT 138, ( result, annotated_formula1left,
9.5408 +annotated_formula1right), rest671)
9.5409 +end
9.5410 +| ( 277, ( ( _, ( MlyValue.include_ include_, include_1left,
9.5411 +include_1right)) :: rest671)) => let val result = MlyValue.tptp_input
9.5412 + (( include_ ))
9.5413 + in ( LrTable.NT 138, ( result, include_1left, include_1right),
9.5414 +rest671)
9.5415 +end
9.5416 +| ( 278, ( ( _, ( MlyValue.tptp_file tptp_file, _, tptp_file1right))
9.5417 + :: ( _, ( MlyValue.tptp_input tptp_input, tptp_input1left, _)) ::
9.5418 +rest671)) => let val result = MlyValue.tptp_file (
9.5419 +( tptp_input :: tptp_file ))
9.5420 + in ( LrTable.NT 139, ( result, tptp_input1left, tptp_file1right),
9.5421 +rest671)
9.5422 +end
9.5423 +| ( 279, ( ( _, ( MlyValue.tptp_file tptp_file, _, tptp_file1right))
9.5424 + :: ( _, ( _, COMMENT1left, _)) :: rest671)) => let val result =
9.5425 +MlyValue.tptp_file (( tptp_file ))
9.5426 + in ( LrTable.NT 139, ( result, COMMENT1left, tptp_file1right),
9.5427 +rest671)
9.5428 +end
9.5429 +| ( 280, ( rest671)) => let val result = MlyValue.tptp_file (( [] ))
9.5430 + in ( LrTable.NT 139, ( result, defaultPos, defaultPos), rest671)
9.5431 +end
9.5432 +| ( 281, ( ( _, ( MlyValue.tptp_file tptp_file, tptp_file1left,
9.5433 +tptp_file1right)) :: rest671)) => let val result = MlyValue.tptp (
9.5434 +( tptp_file ))
9.5435 + in ( LrTable.NT 140, ( result, tptp_file1left, tptp_file1right),
9.5436 +rest671)
9.5437 +end
9.5438 +| _ => raise (mlyAction i392)
9.5439 +end
9.5440 +val void = MlyValue.VOID
9.5441 +val extract = fn a => (fn MlyValue.tptp x => x
9.5442 +| _ => let exception ParseInternal
9.5443 + in raise ParseInternal end) a
9.5444 +end
9.5445 +end
9.5446 +structure Tokens : TPTP_TOKENS =
9.5447 +struct
9.5448 +type svalue = ParserData.svalue
9.5449 +type ('a,'b) token = ('a,'b) Token.token
9.5450 +fun AMPERSAND (p1,p2) = Token.TOKEN (ParserData.LrTable.T 0,(
9.5451 +ParserData.MlyValue.VOID,p1,p2))
9.5452 +fun AT_SIGN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 1,(
9.5453 +ParserData.MlyValue.VOID,p1,p2))
9.5454 +fun CARET (p1,p2) = Token.TOKEN (ParserData.LrTable.T 2,(
9.5455 +ParserData.MlyValue.VOID,p1,p2))
9.5456 +fun COLON (p1,p2) = Token.TOKEN (ParserData.LrTable.T 3,(
9.5457 +ParserData.MlyValue.VOID,p1,p2))
9.5458 +fun COMMA (p1,p2) = Token.TOKEN (ParserData.LrTable.T 4,(
9.5459 +ParserData.MlyValue.VOID,p1,p2))
9.5460 +fun EQUALS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 5,(
9.5461 +ParserData.MlyValue.VOID,p1,p2))
9.5462 +fun EXCLAMATION (p1,p2) = Token.TOKEN (ParserData.LrTable.T 6,(
9.5463 +ParserData.MlyValue.VOID,p1,p2))
9.5464 +fun LET (p1,p2) = Token.TOKEN (ParserData.LrTable.T 7,(
9.5465 +ParserData.MlyValue.VOID,p1,p2))
9.5466 +fun ARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 8,(
9.5467 +ParserData.MlyValue.VOID,p1,p2))
9.5468 +fun IF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 9,(
9.5469 +ParserData.MlyValue.VOID,p1,p2))
9.5470 +fun IFF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 10,(
9.5471 +ParserData.MlyValue.VOID,p1,p2))
9.5472 +fun IMPLIES (p1,p2) = Token.TOKEN (ParserData.LrTable.T 11,(
9.5473 +ParserData.MlyValue.VOID,p1,p2))
9.5474 +fun INCLUDE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 12,(
9.5475 +ParserData.MlyValue.VOID,p1,p2))
9.5476 +fun LAMBDA (p1,p2) = Token.TOKEN (ParserData.LrTable.T 13,(
9.5477 +ParserData.MlyValue.VOID,p1,p2))
9.5478 +fun LBRKT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 14,(
9.5479 +ParserData.MlyValue.VOID,p1,p2))
9.5480 +fun LPAREN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 15,(
9.5481 +ParserData.MlyValue.VOID,p1,p2))
9.5482 +fun MAP_TO (p1,p2) = Token.TOKEN (ParserData.LrTable.T 16,(
9.5483 +ParserData.MlyValue.VOID,p1,p2))
9.5484 +fun MMINUS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 17,(
9.5485 +ParserData.MlyValue.VOID,p1,p2))
9.5486 +fun NAND (p1,p2) = Token.TOKEN (ParserData.LrTable.T 18,(
9.5487 +ParserData.MlyValue.VOID,p1,p2))
9.5488 +fun NEQUALS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 19,(
9.5489 +ParserData.MlyValue.VOID,p1,p2))
9.5490 +fun XOR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 20,(
9.5491 +ParserData.MlyValue.VOID,p1,p2))
9.5492 +fun NOR (p1,p2) = Token.TOKEN (ParserData.LrTable.T 21,(
9.5493 +ParserData.MlyValue.VOID,p1,p2))
9.5494 +fun PERIOD (p1,p2) = Token.TOKEN (ParserData.LrTable.T 22,(
9.5495 +ParserData.MlyValue.VOID,p1,p2))
9.5496 +fun PPLUS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 23,(
9.5497 +ParserData.MlyValue.VOID,p1,p2))
9.5498 +fun QUESTION (p1,p2) = Token.TOKEN (ParserData.LrTable.T 24,(
9.5499 +ParserData.MlyValue.VOID,p1,p2))
9.5500 +fun RBRKT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 25,(
9.5501 +ParserData.MlyValue.VOID,p1,p2))
9.5502 +fun RPAREN (p1,p2) = Token.TOKEN (ParserData.LrTable.T 26,(
9.5503 +ParserData.MlyValue.VOID,p1,p2))
9.5504 +fun TILDE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 27,(
9.5505 +ParserData.MlyValue.VOID,p1,p2))
9.5506 +fun TOK_FALSE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 28,(
9.5507 +ParserData.MlyValue.VOID,p1,p2))
9.5508 +fun TOK_I (p1,p2) = Token.TOKEN (ParserData.LrTable.T 29,(
9.5509 +ParserData.MlyValue.VOID,p1,p2))
9.5510 +fun TOK_O (p1,p2) = Token.TOKEN (ParserData.LrTable.T 30,(
9.5511 +ParserData.MlyValue.VOID,p1,p2))
9.5512 +fun TOK_INT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 31,(
9.5513 +ParserData.MlyValue.VOID,p1,p2))
9.5514 +fun TOK_REAL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 32,(
9.5515 +ParserData.MlyValue.VOID,p1,p2))
9.5516 +fun TOK_RAT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 33,(
9.5517 +ParserData.MlyValue.VOID,p1,p2))
9.5518 +fun TOK_TRUE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 34,(
9.5519 +ParserData.MlyValue.VOID,p1,p2))
9.5520 +fun TOK_TYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 35,(
9.5521 +ParserData.MlyValue.VOID,p1,p2))
9.5522 +fun VLINE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 36,(
9.5523 +ParserData.MlyValue.VOID,p1,p2))
9.5524 +fun EOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 37,(
9.5525 +ParserData.MlyValue.VOID,p1,p2))
9.5526 +fun DTHF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 38,(
9.5527 +ParserData.MlyValue.VOID,p1,p2))
9.5528 +fun DFOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 39,(
9.5529 +ParserData.MlyValue.VOID,p1,p2))
9.5530 +fun DCNF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 40,(
9.5531 +ParserData.MlyValue.VOID,p1,p2))
9.5532 +fun DFOT (p1,p2) = Token.TOKEN (ParserData.LrTable.T 41,(
9.5533 +ParserData.MlyValue.VOID,p1,p2))
9.5534 +fun DTFF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 42,(
9.5535 +ParserData.MlyValue.VOID,p1,p2))
9.5536 +fun REAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 43,(
9.5537 +ParserData.MlyValue.REAL i,p1,p2))
9.5538 +fun RATIONAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 44,(
9.5539 +ParserData.MlyValue.RATIONAL i,p1,p2))
9.5540 +fun SIGNED_INTEGER (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 45,(
9.5541 +ParserData.MlyValue.SIGNED_INTEGER i,p1,p2))
9.5542 +fun UNSIGNED_INTEGER (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 46
9.5543 +,(ParserData.MlyValue.UNSIGNED_INTEGER i,p1,p2))
9.5544 +fun DOT_DECIMAL (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 47,(
9.5545 +ParserData.MlyValue.DOT_DECIMAL i,p1,p2))
9.5546 +fun SINGLE_QUOTED (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 48,(
9.5547 +ParserData.MlyValue.SINGLE_QUOTED i,p1,p2))
9.5548 +fun UPPER_WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 49,(
9.5549 +ParserData.MlyValue.UPPER_WORD i,p1,p2))
9.5550 +fun LOWER_WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 50,(
9.5551 +ParserData.MlyValue.LOWER_WORD i,p1,p2))
9.5552 +fun COMMENT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 51,(
9.5553 +ParserData.MlyValue.COMMENT i,p1,p2))
9.5554 +fun DISTINCT_OBJECT (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T 52,(
9.5555 +ParserData.MlyValue.DISTINCT_OBJECT i,p1,p2))
9.5556 +fun DUD (p1,p2) = Token.TOKEN (ParserData.LrTable.T 53,(
9.5557 +ParserData.MlyValue.VOID,p1,p2))
9.5558 +fun INDEF_CHOICE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 54,(
9.5559 +ParserData.MlyValue.VOID,p1,p2))
9.5560 +fun DEFIN_CHOICE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 55,(
9.5561 +ParserData.MlyValue.VOID,p1,p2))
9.5562 +fun OPERATOR_FORALL (p1,p2) = Token.TOKEN (ParserData.LrTable.T 56,(
9.5563 +ParserData.MlyValue.VOID,p1,p2))
9.5564 +fun OPERATOR_EXISTS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 57,(
9.5565 +ParserData.MlyValue.VOID,p1,p2))
9.5566 +fun PLUS (p1,p2) = Token.TOKEN (ParserData.LrTable.T 58,(
9.5567 +ParserData.MlyValue.VOID,p1,p2))
9.5568 +fun TIMES (p1,p2) = Token.TOKEN (ParserData.LrTable.T 59,(
9.5569 +ParserData.MlyValue.VOID,p1,p2))
9.5570 +fun GENTZEN_ARROW (p1,p2) = Token.TOKEN (ParserData.LrTable.T 60,(
9.5571 +ParserData.MlyValue.VOID,p1,p2))
9.5572 +fun DEP_SUM (p1,p2) = Token.TOKEN (ParserData.LrTable.T 61,(
9.5573 +ParserData.MlyValue.VOID,p1,p2))
9.5574 +fun DEP_PROD (p1,p2) = Token.TOKEN (ParserData.LrTable.T 62,(
9.5575 +ParserData.MlyValue.VOID,p1,p2))
9.5576 +fun ATOMIC_DEFINED_WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T
9.5577 +63,(ParserData.MlyValue.ATOMIC_DEFINED_WORD i,p1,p2))
9.5578 +fun ATOMIC_SYSTEM_WORD (i,p1,p2) = Token.TOKEN (ParserData.LrTable.T
9.5579 +64,(ParserData.MlyValue.ATOMIC_SYSTEM_WORD i,p1,p2))
9.5580 +fun SUBTYPE (p1,p2) = Token.TOKEN (ParserData.LrTable.T 65,(
9.5581 +ParserData.MlyValue.VOID,p1,p2))
9.5582 +fun LET_TERM (p1,p2) = Token.TOKEN (ParserData.LrTable.T 66,(
9.5583 +ParserData.MlyValue.VOID,p1,p2))
9.5584 +fun THF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 67,(
9.5585 +ParserData.MlyValue.VOID,p1,p2))
9.5586 +fun TFF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 68,(
9.5587 +ParserData.MlyValue.VOID,p1,p2))
9.5588 +fun FOF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 69,(
9.5589 +ParserData.MlyValue.VOID,p1,p2))
9.5590 +fun CNF (p1,p2) = Token.TOKEN (ParserData.LrTable.T 70,(
9.5591 +ParserData.MlyValue.VOID,p1,p2))
9.5592 +fun ITE_F (p1,p2) = Token.TOKEN (ParserData.LrTable.T 71,(
9.5593 +ParserData.MlyValue.VOID,p1,p2))
9.5594 +fun ITE_T (p1,p2) = Token.TOKEN (ParserData.LrTable.T 72,(
9.5595 +ParserData.MlyValue.VOID,p1,p2))
9.5596 +end
9.5597 +end
10.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
10.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp_parser.ML Fri Mar 09 15:38:55 2012 +0000
10.3 @@ -0,0 +1,73 @@
10.4 +(* Title: HOL/TPTP/TPTP_Parser/tptp_parser.ML
10.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
10.6 +
10.7 +An interface for a parser, generated using ML-Yacc, to parse TPTP languages.
10.8 +*)
10.9 +
10.10 +
10.11 +(* Build the parser structure *)
10.12 +
10.13 +structure TPTPLrVals = TPTPLrValsFun(structure Token = LrParser.Token)
10.14 +structure TPTPLex = TPTPLexFun(structure Tokens = TPTPLrVals.Tokens)
10.15 +structure TPTPParser
10.16 + = JoinWithArg
10.17 + (structure ParserData = TPTPLrVals.ParserData
10.18 + structure Lex = TPTPLex
10.19 + structure LrParser = LrParser)
10.20 +
10.21 +
10.22 +(* Parser interface *)
10.23 +structure TPTP_Parser :
10.24 +sig
10.25 + val parse_file : string -> TPTP_Syntax.tptp_problem
10.26 + val parse_expression : string -> string -> TPTP_Syntax.tptp_problem
10.27 + exception TPTP_PARSE_ERROR
10.28 +end =
10.29 +struct
10.30 +
10.31 +exception TPTP_PARSE_ERROR
10.32 +
10.33 +val LOOKAHEAD = 0 (*usually set to 15*)
10.34 +
10.35 +local
10.36 + fun print_error file_name (msg, line, col) =
10.37 + error (file_name ^ "[" ^ Int.toString line ^ ":" ^ Int.toString col ^ "] " ^
10.38 + msg ^ "\n")
10.39 + fun parse lookahead grab file_name =
10.40 + TPTPParser.parse
10.41 + (lookahead,
10.42 + TPTPParser.makeLexer grab file_name,
10.43 + print_error file_name,
10.44 + file_name)
10.45 +in
10.46 + fun parse_expression file_name expression =
10.47 + (*file_name only used in reporting error messages*)
10.48 + let
10.49 + val currentPos = Unsynchronized.ref 0
10.50 + fun grab n =
10.51 + if !currentPos = String.size expression then ""
10.52 + else
10.53 + let
10.54 + fun extractStr n =
10.55 + let
10.56 + val s = String.extract (expression, !currentPos, SOME n)
10.57 + in
10.58 + currentPos := !currentPos + n;
10.59 + s
10.60 + end
10.61 + val remaining = String.size expression - !currentPos
10.62 + in if remaining < n then extractStr remaining else extractStr n
10.63 + end
10.64 + val (tree, _ (*remainder*)) =
10.65 + parse LOOKAHEAD grab file_name
10.66 + in tree end
10.67 +
10.68 + fun parse_file' lookahead file_name =
10.69 + parse_expression
10.70 + file_name
10.71 + (File.open_input TextIO.inputAll (Path.explode file_name))
10.72 +end
10.73 +
10.74 +val parse_file = parse_file' LOOKAHEAD
10.75 +
10.76 +end
11.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
11.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp_problem_name.ML Fri Mar 09 15:38:55 2012 +0000
11.3 @@ -0,0 +1,150 @@
11.4 +(* Title: HOL/TPTP/TPTP_Parser/tptp_problem_name.ML
11.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
11.6 +
11.7 +Scans a TPTP problem name. Naming convention is described
11.8 +http://www.cs.miami.edu/~tptp/TPTP/TR/TPTPTR.shtml#Problem and Axiomatization Naming
11.9 +*)
11.10 +
11.11 +signature TPTP_PROBLEM_NAME =
11.12 +sig
11.13 + datatype suffix =
11.14 + Problem of
11.15 + ((*version*)int *
11.16 + (*size parameter*)int option) *
11.17 + (*extension*)string
11.18 + | Axiom of
11.19 + (*specialisation*)int *
11.20 + (*extension*)string
11.21 +
11.22 + type tptp_problem_name =
11.23 + {prob_domain : string,
11.24 + prob_number : int,
11.25 + prob_form : TPTP_Syntax.language,
11.26 + suffix : suffix}
11.27 +
11.28 + datatype problem_name =
11.29 + Standard of tptp_problem_name
11.30 + | Nonstandard of string
11.31 +
11.32 + exception TPTP_PROBLEM_NAME of string
11.33 +
11.34 + val parse_problem_name : string -> problem_name
11.35 + val mangle_problem_name : problem_name -> string
11.36 +end
11.37 +
11.38 +structure TPTP_Problem_Name: TPTP_PROBLEM_NAME =
11.39 +struct
11.40 +
11.41 +(*some basic tokens*)
11.42 +val numerics = map Char.chr (48 upto 57) (*0..9*)
11.43 +val alphabetics =
11.44 + map Char.chr (65 upto 90) @ (*A..Z*)
11.45 + map Char.chr (97 upto 122) (*a..z*)
11.46 +(*TPTP formula forms*)
11.47 +val forms = [#"^", #"_", #"=", #"+", #"-"]
11.48 +
11.49 +(*lift a list of characters into a scanner combinator matching any one of the
11.50 +characters in that list.*)
11.51 +fun lift l =
11.52 + (map (Char.toString #> ($$)) l, Scan.fail)
11.53 + |-> fold (fn x => fn y => x || y)
11.54 +
11.55 +(*combinators for parsing letters and numbers*)
11.56 +val alpha = lift alphabetics
11.57 +val numer = lift numerics
11.58 +
11.59 +datatype suffix =
11.60 + Problem of
11.61 + ((*version*)int *
11.62 + (*size parameter*)int option) *
11.63 + (*extension*)string
11.64 + | Axiom of
11.65 + (*specialisation*)int *
11.66 + (*extension*)string
11.67 +
11.68 +val to_int = Int.fromString #> the
11.69 +val rm_ending = Scan.this_string "rm"
11.70 +val ax_ending =
11.71 + ((numer >> to_int) --|
11.72 + $$ "." -- (Scan.this_string "eq" || Scan.this_string "ax" || rm_ending))
11.73 + >> Axiom
11.74 +val prob_ending = $$ "p" || $$ "g" || rm_ending
11.75 +val prob_suffix =
11.76 + ((numer >> to_int) --
11.77 + Scan.option ($$ "." |-- numer ^^ numer ^^ numer >> to_int) --| $$ "."
11.78 + -- prob_ending)
11.79 + >> Problem
11.80 +
11.81 +type tptp_problem_name =
11.82 + {prob_domain : string,
11.83 + prob_number : int,
11.84 + prob_form : TPTP_Syntax.language,
11.85 + suffix : suffix}
11.86 +
11.87 +datatype problem_name =
11.88 + Standard of tptp_problem_name
11.89 + | Nonstandard of string
11.90 +
11.91 +exception TPTP_PROBLEM_NAME of string
11.92 +
11.93 +(*FIXME add graceful handling on non-wellformed TPTP filenames*)
11.94 +fun parse_problem_name str' : problem_name =
11.95 + let
11.96 + val str = Symbol.explode str'
11.97 + (*NOTE there's an ambiguity in the spec: there's no way of knowing if a
11.98 + file ending in "rm" used to be "ax" or "p". Here we default to "p".*)
11.99 + val ((((prob_domain, prob_number), prob_form), suffix), rest) =
11.100 + Scan.finite Symbol.stopper
11.101 + ((alpha ^^ alpha ^^ alpha) --
11.102 + (numer ^^ numer ^^ numer >> to_int) --
11.103 + lift forms -- (prob_suffix || ax_ending)) str
11.104 +
11.105 + fun parse_form str =
11.106 + case str of
11.107 + "^" => TPTP_Syntax.THF
11.108 + | "_" => TPTP_Syntax.TFF
11.109 + | "=" => TPTP_Syntax.TFF_with_arithmetic
11.110 + | "+" => TPTP_Syntax.FOF
11.111 + | "-" => TPTP_Syntax.CNF
11.112 + | _ => raise TPTP_PROBLEM_NAME ("Unknown TPTP form: " ^ str)
11.113 + in
11.114 + if null rest (*check if the whole name was parsed*)
11.115 + then
11.116 + Standard
11.117 + {prob_domain = prob_domain,
11.118 + prob_number = prob_number,
11.119 + prob_form = parse_form prob_form,
11.120 + suffix = suffix}
11.121 + handle _ => Nonstandard str'
11.122 + else raise TPTP_PROBLEM_NAME ("Parse error")
11.123 + end
11.124 +
11.125 +(*Produces an ASCII encoding of a TPTP problem-file name.*)
11.126 +fun mangle_problem_name (prob : problem_name) : string =
11.127 + case prob of
11.128 + Standard tptp_prob =>
11.129 + let
11.130 + val prob_form =
11.131 + case #prob_form tptp_prob of
11.132 + TPTP_Syntax.THF => "_thf_"
11.133 + | TPTP_Syntax.TFF => "_tff_"
11.134 + | TPTP_Syntax.TFF_with_arithmetic => "_thfwa_"
11.135 + | TPTP_Syntax.FOF => "_fof_"
11.136 + | TPTP_Syntax.CNF => "_cnf_"
11.137 + val suffix =
11.138 + case #suffix tptp_prob of
11.139 + Problem ((version, size), extension) =>
11.140 + Int.toString version ^ "_" ^
11.141 + (if is_some size then Int.toString (the size) ^ "_" else "") ^
11.142 + extension
11.143 + | Axiom (specialisation, extension) =>
11.144 + Int.toString specialisation ^ "_" ^ extension
11.145 + in
11.146 + #prob_domain tptp_prob ^
11.147 + Int.toString (#prob_number tptp_prob) ^
11.148 + prob_form ^
11.149 + suffix
11.150 + end
11.151 + | Nonstandard str => str
11.152 +
11.153 +end
12.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
12.2 +++ b/src/HOL/TPTP/TPTP_Parser/tptp_syntax.ML Fri Mar 09 15:38:55 2012 +0000
12.3 @@ -0,0 +1,489 @@
12.4 +(* Title: HOL/TPTP/TPTP_Parser/tptp_syntax.ML
12.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
12.6 +
12.7 +TPTP abstract syntax and parser-related definitions.
12.8 +*)
12.9 +
12.10 +signature TPTP_SYNTAX =
12.11 +sig
12.12 + exception TPTP_SYNTAX of string
12.13 + val debug: ('a -> unit) -> 'a -> unit
12.14 +
12.15 +(*Note that in THF "^ [X] : ^ [Y] : f @ g" should parse
12.16 + as "(^ [X] : (^ [Y] : f)) @ g"
12.17 +*)
12.18 +
12.19 + datatype number_kind = Int_num | Real_num | Rat_num
12.20 +
12.21 + datatype status_value =
12.22 + Suc | Unp | Sap | Esa | Sat | Fsa
12.23 + | Thm | Eqv | Tac | Wec | Eth | Tau
12.24 + | Wtc | Wth | Cax | Sca | Tca | Wca
12.25 + | Cup | Csp | Ecs | Csa | Cth | Ceq
12.26 + | Unc | Wcc | Ect | Fun | Uns | Wuc
12.27 + | Wct | Scc | Uca | Noc
12.28 +
12.29 + type name = string
12.30 + type atomic_word = string
12.31 + type inference_rule = atomic_word
12.32 + type file_info = name option
12.33 + type single_quoted = string
12.34 + type file_name = single_quoted
12.35 + type creator_name = atomic_word
12.36 + type variable = string
12.37 + type upper_word = string
12.38 +
12.39 + datatype language = FOF | CNF | TFF | THF | FOT | TFF_with_arithmetic
12.40 + and role =
12.41 + Role_Axiom | Role_Hypothesis | Role_Definition | Role_Assumption |
12.42 + Role_Lemma | Role_Theorem | Role_Conjecture | Role_Negated_Conjecture |
12.43 + Role_Plain | Role_Fi_Domain | Role_Fi_Functors | Role_Fi_Predicates |
12.44 + Role_Type | Role_Unknown
12.45 +
12.46 + and general_data = (*Bind of variable * formula_data*)
12.47 + Atomic_Word of string
12.48 + | Application of string * general_term list (*general_function*)
12.49 + | V of upper_word (*variable*)
12.50 + | Number of number_kind * string
12.51 + | Distinct_Object of string
12.52 + | (*formula_data*) Formula_Data of language * tptp_formula (* $thf(<thf_formula>) *)
12.53 + | (*formula_data*) Term_Data of tptp_term
12.54 +
12.55 + and interpreted_symbol =
12.56 + UMinus | Sum | Difference | Product | Quotient | Quotient_E |
12.57 + Quotient_T | Quotient_F | Remainder_E | Remainder_T | Remainder_F |
12.58 + Floor | Ceiling | Truncate | Round | To_Int | To_Rat | To_Real |
12.59 + (*these should be in defined_pred, but that's not being used in TPTP*)
12.60 + Less | LessEq | Greater | GreaterEq | EvalEq | Is_Int | Is_Rat |
12.61 + Apply (*this is just a matter of convenience*)
12.62 +
12.63 + and logic_symbol = Equals | NEquals | Or | And | Iff | If | Fi | Xor |
12.64 + Nor | Nand | Not | Op_Forall | Op_Exists |
12.65 + (*these should be in defined_pred, but that's not being used in TPTP*)
12.66 + True | False
12.67 +
12.68 + and quantifier = (*interpreted binders*)
12.69 + Forall | Exists | Epsilon | Iota | Lambda | Dep_Prod | Dep_Sum
12.70 +
12.71 + and tptp_base_type =
12.72 + Type_Ind | Type_Bool | Type_Type | Type_Int | Type_Rat | Type_Real
12.73 +
12.74 + and symbol =
12.75 + Uninterpreted of string
12.76 + | Interpreted_ExtraLogic of interpreted_symbol
12.77 + | Interpreted_Logic of logic_symbol
12.78 + | TypeSymbol of tptp_base_type
12.79 + | System of string
12.80 +
12.81 + and general_term =
12.82 + General_Data of general_data (*general_data*)
12.83 + | General_Term of general_data * general_term (*general_data : general_term*)
12.84 + | General_List of general_term list
12.85 +
12.86 + and tptp_term =
12.87 + Term_Func of symbol * tptp_term list
12.88 + | Term_Var of string
12.89 + | Term_Conditional of tptp_formula * tptp_term * tptp_term
12.90 + | Term_Num of number_kind * string
12.91 + | Term_Distinct_Object of string
12.92 +
12.93 + and tptp_atom =
12.94 + TFF_Typed_Atom of symbol * tptp_type option (*only TFF*)
12.95 + | THF_Atom_term of tptp_term (*from here on, only THF*)
12.96 + | THF_Atom_conn_term of symbol
12.97 +
12.98 + and tptp_formula =
12.99 + Pred of symbol * tptp_term list
12.100 + | Fmla of symbol * tptp_formula list
12.101 + | Sequent of tptp_formula list * tptp_formula list
12.102 + | Quant of quantifier * (string * tptp_type option) list * tptp_formula
12.103 + | Conditional of tptp_formula * tptp_formula * tptp_formula
12.104 + | Let of tptp_let list * tptp_formula
12.105 + | Atom of tptp_atom
12.106 + | THF_type of tptp_type
12.107 + | THF_typing of tptp_formula * tptp_type (*only THF*)
12.108 +
12.109 + and tptp_let =
12.110 + Let_fmla of (string * tptp_type option) * tptp_formula
12.111 + | Let_term of (string * tptp_type option) * tptp_term (*only TFF*)
12.112 +
12.113 + and tptp_type =
12.114 + Prod_type of tptp_type * tptp_type
12.115 + | Fn_type of tptp_type * tptp_type
12.116 + | Atom_type of string
12.117 + | Defined_type of tptp_base_type
12.118 + | Sum_type of tptp_type * tptp_type (*only THF*)
12.119 + | Fmla_type of tptp_formula (*only THF*)
12.120 + | Subtype of symbol * symbol (*only THF*)
12.121 +
12.122 + type general_list = general_term list
12.123 + type parent_details = general_list
12.124 + type useful_info = general_term list
12.125 + type info = useful_info
12.126 +
12.127 + type annotation = general_term * general_term list
12.128 +
12.129 + exception DEQUOTE of string
12.130 +
12.131 + type position = string * int * int
12.132 +
12.133 + datatype tptp_line =
12.134 + Annotated_Formula of position * language * string * role * tptp_formula * annotation option
12.135 + | Include of string * string list
12.136 +
12.137 + type tptp_problem = tptp_line list
12.138 +
12.139 + val dequote : single_quoted -> single_quoted
12.140 +
12.141 + val role_to_string : role -> string
12.142 +
12.143 + val status_to_string : status_value -> string
12.144 +
12.145 + val nameof_tff_atom_type : tptp_type -> string
12.146 +
12.147 + (*Returns the list of all files included in a directory and its
12.148 + subdirectories. This is only used for testing the parser/interpreter against
12.149 + all THF problems.*)
12.150 + val get_file_list : Path.T -> Path.T list
12.151 +
12.152 + val string_of_tptp_term : tptp_term -> string
12.153 + val string_of_tptp_formula : tptp_formula -> string
12.154 +
12.155 +end
12.156 +
12.157 +
12.158 +structure TPTP_Syntax : TPTP_SYNTAX =
12.159 +struct
12.160 +
12.161 +exception TPTP_SYNTAX of string
12.162 +
12.163 +datatype number_kind = Int_num | Real_num | Rat_num
12.164 +
12.165 +datatype status_value =
12.166 + Suc | Unp | Sap | Esa | Sat | Fsa
12.167 + | Thm | Eqv | Tac | Wec | Eth | Tau
12.168 + | Wtc | Wth | Cax | Sca | Tca | Wca
12.169 + | Cup | Csp | Ecs | Csa | Cth | Ceq
12.170 + | Unc | Wcc | Ect | Fun | Uns | Wuc
12.171 + | Wct | Scc | Uca | Noc
12.172 +
12.173 +type name = string
12.174 +type atomic_word = string
12.175 +type inference_rule = atomic_word
12.176 +type file_info = name option
12.177 +type single_quoted = string
12.178 +type file_name = single_quoted
12.179 +type creator_name = atomic_word
12.180 +type variable = string
12.181 +type upper_word = string
12.182 +
12.183 +datatype language = FOF | CNF | TFF | THF | FOT | TFF_with_arithmetic
12.184 +and role =
12.185 + Role_Axiom | Role_Hypothesis | Role_Definition | Role_Assumption |
12.186 + Role_Lemma | Role_Theorem | Role_Conjecture | Role_Negated_Conjecture |
12.187 + Role_Plain | Role_Fi_Domain | Role_Fi_Functors | Role_Fi_Predicates |
12.188 + Role_Type | Role_Unknown
12.189 +and general_data = (*Bind of variable * formula_data*)
12.190 + Atomic_Word of string
12.191 + | Application of string * (general_term list)
12.192 + | V of upper_word (*variable*)
12.193 + | Number of number_kind * string
12.194 + | Distinct_Object of string
12.195 + | (*formula_data*) Formula_Data of language * tptp_formula (* $thf(<thf_formula>) *)
12.196 + | (*formula_data*) Term_Data of tptp_term
12.197 +
12.198 + and interpreted_symbol =
12.199 + UMinus | Sum | Difference | Product | Quotient | Quotient_E |
12.200 + Quotient_T | Quotient_F | Remainder_E | Remainder_T | Remainder_F |
12.201 + Floor | Ceiling | Truncate | Round | To_Int | To_Rat | To_Real |
12.202 + (*these should be in defined_pred, but that's not being used in TPTP*)
12.203 + Less | LessEq | Greater | GreaterEq | EvalEq | Is_Int | Is_Rat |
12.204 + Apply (*this is just a matter of convenience*)
12.205 +
12.206 + and logic_symbol = Equals | NEquals | Or | And | Iff | If | Fi | Xor |
12.207 + Nor | Nand | Not | Op_Forall | Op_Exists |
12.208 + (*these should be in defined_pred, but that's not being used in TPTP*)
12.209 + True | False
12.210 +
12.211 + and quantifier = (*interpreted binders*)
12.212 + Forall | Exists | Epsilon | Iota | Lambda | Dep_Prod | Dep_Sum
12.213 +
12.214 + and tptp_base_type =
12.215 + Type_Ind | Type_Bool | Type_Type | Type_Int | Type_Rat | Type_Real
12.216 +
12.217 + and symbol =
12.218 + Uninterpreted of string
12.219 + | Interpreted_ExtraLogic of interpreted_symbol
12.220 + | Interpreted_Logic of logic_symbol
12.221 + | TypeSymbol of tptp_base_type
12.222 + | System of string
12.223 +
12.224 + and general_term =
12.225 + General_Data of general_data (*general_data*)
12.226 + | General_Term of general_data * general_term (*general_data : general_term*)
12.227 + | General_List of general_term list
12.228 +
12.229 + and tptp_term =
12.230 + Term_Func of symbol * tptp_term list
12.231 + | Term_Var of string
12.232 + | Term_Conditional of tptp_formula * tptp_term * tptp_term
12.233 + | Term_Num of number_kind * string
12.234 + | Term_Distinct_Object of string
12.235 +
12.236 + and tptp_atom =
12.237 + TFF_Typed_Atom of symbol * tptp_type option (*only TFF*)
12.238 + | THF_Atom_term of tptp_term (*from here on, only THF*)
12.239 + | THF_Atom_conn_term of symbol
12.240 +
12.241 + and tptp_formula =
12.242 + Pred of symbol * tptp_term list
12.243 + | Fmla of symbol * tptp_formula list
12.244 + | Sequent of tptp_formula list * tptp_formula list
12.245 + | Quant of quantifier * (string * tptp_type option) list * tptp_formula
12.246 + | Conditional of tptp_formula * tptp_formula * tptp_formula
12.247 + | Let of tptp_let list * tptp_formula
12.248 + | Atom of tptp_atom
12.249 + | THF_type of tptp_type
12.250 + | THF_typing of tptp_formula * tptp_type
12.251 +
12.252 + and tptp_let =
12.253 + Let_fmla of (string * tptp_type option) * tptp_formula (*both TFF and THF*)
12.254 + | Let_term of (string * tptp_type option) * tptp_term (*only TFF*)
12.255 +
12.256 + and tptp_type =
12.257 + Prod_type of tptp_type * tptp_type
12.258 + | Fn_type of tptp_type * tptp_type
12.259 + | Atom_type of string
12.260 + | Defined_type of tptp_base_type
12.261 + | Sum_type of tptp_type * tptp_type (*only THF*)
12.262 + | Fmla_type of tptp_formula (*only THF*)
12.263 + | Subtype of symbol * symbol (*only THF*)
12.264 +
12.265 +type general_list = general_term list
12.266 +type parent_details = general_list
12.267 +type useful_info = general_term list
12.268 +type info = useful_info
12.269 +
12.270 +(*type annotation = (source * info option)*)
12.271 +type annotation = general_term * general_term list
12.272 +
12.273 +exception DEQUOTE of string
12.274 +
12.275 +(*
12.276 +datatype defined_functor =
12.277 + ITE_T | UMINUS | SUM | DIFFERENCE | PRODUCT | QUOTIENT | QUOTIENT_E |
12.278 + QUOTIENT_T | QUOTIENT_F | REMAINDER_E | REMAINDER_T | REMAINDER_F |
12.279 + FLOOR | CEILING | TRUNCATE | ROUND | TO_INT | TO_RAT | TO_REAL
12.280 +*)
12.281 +
12.282 +type position = string * int * int
12.283 +
12.284 +datatype tptp_line =
12.285 + Annotated_Formula of position * language * string * role * tptp_formula * annotation option
12.286 + | Include of string * string list
12.287 +
12.288 +type tptp_problem = tptp_line list
12.289 +
12.290 +fun debug f x = if !Runtime.debug then (f x; ()) else ()
12.291 +
12.292 +fun nameof_tff_atom_type (Atom_type str) = str
12.293 + | nameof_tff_atom_type _ = raise TPTP_SYNTAX "nameof_tff_atom_type called on non-atom type"
12.294 +
12.295 +(*Used for debugging. Returns all files contained within a directory or its
12.296 +subdirectories. Follows symbolic links, filters away directories.*)
12.297 +fun get_file_list path =
12.298 + let
12.299 + fun check_file_entry f rest =
12.300 + let
12.301 + (*NOTE needed since no File.is_link and File.read_link*)
12.302 + val f_str = Path.implode f
12.303 + in
12.304 + if File.is_dir f then
12.305 + rest @ get_file_list f
12.306 + else if OS.FileSys.isLink f_str then
12.307 + (*follow links -- NOTE this breaks if links are relative paths*)
12.308 + check_file_entry (Path.explode (OS.FileSys.readLink f_str)) rest
12.309 + else f :: rest
12.310 + end
12.311 + in
12.312 + File.read_dir path
12.313 + |> map
12.314 + (Path.explode
12.315 + #> Path.append path)
12.316 + |> (fn l => fold check_file_entry l [])
12.317 + end
12.318 +
12.319 +fun role_to_string role =
12.320 + case role of
12.321 + Role_Axiom => "axiom"
12.322 + | Role_Hypothesis => "hypothesis"
12.323 + | Role_Definition => "definition"
12.324 + | Role_Assumption => "assumption"
12.325 + | Role_Lemma => "lemma"
12.326 + | Role_Theorem => "theorem"
12.327 + | Role_Conjecture => "conjecture"
12.328 + | Role_Negated_Conjecture => "negated_conjecture"
12.329 + | Role_Plain => "plain"
12.330 + | Role_Fi_Domain => "fi_domain"
12.331 + | Role_Fi_Functors => "fi_functors"
12.332 + | Role_Fi_Predicates => "fi_predicates"
12.333 + | Role_Type => "type"
12.334 + | Role_Unknown => "unknown"
12.335 +
12.336 +(*accepts a string "'abc'" and returns "abc"*)
12.337 +fun dequote str : single_quoted =
12.338 + if str = "" then
12.339 + raise (DEQUOTE "empty string")
12.340 + else
12.341 + (unprefix "'" str
12.342 + |> unsuffix "'"
12.343 + handle (Fail str) =>
12.344 + if str = "unprefix" then
12.345 + raise DEQUOTE ("string doesn't open with quote:" ^ str)
12.346 + else if str = "unsuffix" then
12.347 + raise DEQUOTE ("string doesn't close with quote:" ^ str)
12.348 + else raise Fail str)
12.349 +
12.350 +
12.351 +(* Printing parsed TPTP formulas *)
12.352 +(*FIXME this is not pretty-printing, just printing*)
12.353 +
12.354 +fun status_to_string status_value =
12.355 + case status_value of
12.356 + Suc => "suc" | Unp => "unp"
12.357 + | Sap => "sap" | Esa => "esa"
12.358 + | Sat => "sat" | Fsa => "fsa"
12.359 + | Thm => "thm" | Wuc => "wuc"
12.360 + | Eqv => "eqv" | Tac => "tac"
12.361 + | Wec => "wec" | Eth => "eth"
12.362 + | Tau => "tau" | Wtc => "wtc"
12.363 + | Wth => "wth" | Cax => "cax"
12.364 + | Sca => "sca" | Tca => "tca"
12.365 + | Wca => "wca" | Cup => "cup"
12.366 + | Csp => "csp" | Ecs => "ecs"
12.367 + | Csa => "csa" | Cth => "cth"
12.368 + | Ceq => "ceq" | Unc => "unc"
12.369 + | Wcc => "wcc" | Ect => "ect"
12.370 + | Fun => "fun" | Uns => "uns"
12.371 + | Wct => "wct" | Scc => "scc"
12.372 + | Uca => "uca" | Noc => "noc"
12.373 +
12.374 +fun string_of_tptp_term x =
12.375 + case x of
12.376 + Term_Func (symbol, tptp_term_list) =>
12.377 + "(" ^ string_of_symbol symbol ^ " " ^
12.378 + String.concatWith " " (map string_of_tptp_term tptp_term_list) ^ ")"
12.379 + | Term_Var str => str
12.380 + | Term_Conditional (tptp_formula, tptp_term1, tptp_term2) => "" (*FIXME*)
12.381 + | Term_Num (_, str) => str
12.382 + | Term_Distinct_Object str => str
12.383 +
12.384 +and string_of_symbol (Uninterpreted str) = str
12.385 + | string_of_symbol (Interpreted_ExtraLogic interpreted_symbol) = string_of_interpreted_symbol interpreted_symbol
12.386 + | string_of_symbol (Interpreted_Logic logic_symbol) = string_of_logic_symbol logic_symbol
12.387 + | string_of_symbol (TypeSymbol tptp_base_type) = string_of_tptp_base_type tptp_base_type
12.388 + | string_of_symbol (System str) = str
12.389 +
12.390 +and string_of_tptp_base_type Type_Ind = "$i"
12.391 + | string_of_tptp_base_type Type_Bool = "$o"
12.392 + | string_of_tptp_base_type Type_Type = "$tType"
12.393 + | string_of_tptp_base_type Type_Int = "$int"
12.394 + | string_of_tptp_base_type Type_Rat = "$rat"
12.395 + | string_of_tptp_base_type Type_Real = "$real"
12.396 +
12.397 +and string_of_interpreted_symbol x =
12.398 + case x of
12.399 + UMinus => "$uminus"
12.400 + | Sum => "$sum"
12.401 + | Difference => "$difference"
12.402 + | Product => "$product"
12.403 + | Quotient => "$quotient"
12.404 + | Quotient_E => "$quotient_e"
12.405 + | Quotient_T => "$quotient_t"
12.406 + | Quotient_F => "$quotient_f"
12.407 + | Remainder_E => "$remainder_e"
12.408 + | Remainder_T => "$remainder_t"
12.409 + | Remainder_F => "$remainder_f"
12.410 + | Floor => "$floor"
12.411 + | Ceiling => "$ceiling"
12.412 + | Truncate => "$truncate"
12.413 + | Round => "$round"
12.414 + | To_Int => "$to_int"
12.415 + | To_Rat => "$to_rat"
12.416 + | To_Real => "$to_real"
12.417 + | Less => "$less"
12.418 + | LessEq => "$lesseq"
12.419 + | Greater => "$greater"
12.420 + | GreaterEq => "$greatereq"
12.421 + | EvalEq => "$evaleq"
12.422 + | Is_Int => "$is_int"
12.423 + | Is_Rat => "$is_rat"
12.424 + | Apply => "@"
12.425 +
12.426 +and string_of_logic_symbol Equals = "="
12.427 + | string_of_logic_symbol NEquals = "!="
12.428 + | string_of_logic_symbol Or = "|"
12.429 + | string_of_logic_symbol And = "&"
12.430 + | string_of_logic_symbol Iff = "<=>"
12.431 + | string_of_logic_symbol If = "=>"
12.432 + | string_of_logic_symbol Fi = "<="
12.433 + | string_of_logic_symbol Xor = "<~>"
12.434 + | string_of_logic_symbol Nor = "~|"
12.435 + | string_of_logic_symbol Nand = "~&"
12.436 + | string_of_logic_symbol Not = "~"
12.437 + | string_of_logic_symbol Op_Forall = "!!"
12.438 + | string_of_logic_symbol Op_Exists = "??"
12.439 + | string_of_logic_symbol True = "$true"
12.440 + | string_of_logic_symbol False = "$false"
12.441 +
12.442 +and string_of_quantifier Forall = "!"
12.443 + | string_of_quantifier Exists = "?"
12.444 + | string_of_quantifier Epsilon = "@+"
12.445 + | string_of_quantifier Iota = "@-"
12.446 + | string_of_quantifier Lambda = "^"
12.447 + | string_of_quantifier Dep_Prod = "!>"
12.448 + | string_of_quantifier Dep_Sum = "?*"
12.449 +
12.450 +and string_of_tptp_atom (TFF_Typed_Atom (symbol, tptp_type_option)) =
12.451 + (case tptp_type_option of
12.452 + NONE => string_of_symbol symbol
12.453 + | SOME tptp_type =>
12.454 + string_of_symbol symbol ^ " : " ^ string_of_tptp_type tptp_type)
12.455 + | string_of_tptp_atom (THF_Atom_term tptp_term) = string_of_tptp_term tptp_term
12.456 + | string_of_tptp_atom (THF_Atom_conn_term symbol) = string_of_symbol symbol
12.457 +
12.458 +and string_of_tptp_formula (Pred (symbol, tptp_term_list)) =
12.459 + "(" ^ string_of_symbol symbol ^
12.460 + String.concatWith " " (map string_of_tptp_term tptp_term_list) ^ ")"
12.461 + | string_of_tptp_formula (Fmla (symbol, tptp_formula_list)) =
12.462 + "(" ^
12.463 + string_of_symbol symbol ^
12.464 + String.concatWith " " (map string_of_tptp_formula tptp_formula_list) ^ ")"
12.465 + | string_of_tptp_formula (Sequent (tptp_formula_list1, tptp_formula_list2)) = "" (*FIXME*)
12.466 + | string_of_tptp_formula (Quant (quantifier, varlist, tptp_formula)) =
12.467 + string_of_quantifier quantifier ^ "[" ^
12.468 + String.concatWith ", " (map (fn (n, ty) =>
12.469 + case ty of
12.470 + NONE => n
12.471 + | SOME ty => n ^ " : " ^ string_of_tptp_type ty) varlist) ^ "] : (" ^
12.472 + string_of_tptp_formula tptp_formula ^ ")"
12.473 + | string_of_tptp_formula (Conditional _) = "" (*FIXME*)
12.474 + | string_of_tptp_formula (Let _) = "" (*FIXME*)
12.475 + | string_of_tptp_formula (Atom tptp_atom) = string_of_tptp_atom tptp_atom
12.476 + | string_of_tptp_formula (THF_type tptp_type) = string_of_tptp_type tptp_type
12.477 + | string_of_tptp_formula (THF_typing (tptp_formula, tptp_type)) =
12.478 + string_of_tptp_formula tptp_formula ^ " : " ^ string_of_tptp_type tptp_type
12.479 +
12.480 +and string_of_tptp_type (Prod_type (tptp_type1, tptp_type2)) =
12.481 + string_of_tptp_type tptp_type1 ^ " * " ^ string_of_tptp_type tptp_type2
12.482 + | string_of_tptp_type (Fn_type (tptp_type1, tptp_type2)) =
12.483 + string_of_tptp_type tptp_type1 ^ " > " ^ string_of_tptp_type tptp_type2
12.484 + | string_of_tptp_type (Atom_type str) = str
12.485 + | string_of_tptp_type (Defined_type tptp_base_type) =
12.486 + string_of_tptp_base_type tptp_base_type
12.487 + | string_of_tptp_type (Sum_type (tptp_type1, tptp_type2)) = ""
12.488 + | string_of_tptp_type (Fmla_type tptp_formula) = string_of_tptp_formula tptp_formula
12.489 + | string_of_tptp_type (Subtype (symbol1, symbol2)) =
12.490 + string_of_symbol symbol1 ^ " << " ^ string_of_symbol symbol2
12.491 +
12.492 +end
13.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
13.2 +++ b/src/HOL/TPTP/TPTP_Parser_Test.thy Fri Mar 09 15:38:55 2012 +0000
13.3 @@ -0,0 +1,241 @@
13.4 +(* Title: HOL/TPTP/TPTP_Parser_Test.thy
13.5 + Author: Nik Sultana, Cambridge University Computer Laboratory
13.6 +
13.7 +Some tests for the TPTP interface. Some of the tests rely on the Isabelle
13.8 +environment variable TPTP_PROBLEMS_PATH, which should point to the
13.9 +TPTP-vX.Y.Z/Problems directory.
13.10 +*)
13.11 +
13.12 +theory TPTP_Parser_Test
13.13 +imports TPTP_Parser
13.14 +begin
13.15 +
13.16 +ML {*
13.17 + val warning_out = Attrib.setup_config_string @{binding "warning_out"} (K "")
13.18 + fun S x y z = x z (y z)
13.19 +*}
13.20 +
13.21 +section "Parser tests"
13.22 +
13.23 +ML {*
13.24 + fun payload_of (TPTP_Syntax.Annotated_Formula (_, _, _, _, fmla, _)) = fmla
13.25 + val payloads_of = map payload_of
13.26 +*}
13.27 +ML {*
13.28 + TPTP_Parser.parse_expression "" "fof(dt_k4_waybel34, axiom, ~ v3).";
13.29 + TPTP_Parser.parse_expression "" "thf(dt_k4_waybel34, axiom, ~ ($true | $false)).";
13.30 + TPTP_Parser.parse_expression ""
13.31 + "thf(dt_k4_waybel34, axiom, ~ (! [X : $o, Y : ($o > $o)] : ( (X | (Y = Y))))).";
13.32 + TPTP_Parser.parse_expression "" "tff(dt_k4_waybel34, axiom, ~ ($true)).";
13.33 + payloads_of it;
13.34 +*}
13.35 +ML {*
13.36 + TPTP_Parser.parse_expression "" "thf(bla, type, x : $o).";
13.37 + TPTP_Parser.parse_expression ""
13.38 + "fof(dt_k4_waybel34, axiom, ~ v3_struct_0(k4_waybel34(A))).";
13.39 + TPTP_Parser.parse_expression ""
13.40 + "fof(dt_k4_waybel34, axiom, (! [A] : (v1_xboole_0(A) => ( ~ v3_struct_0(k4_waybel34(A)))))).";
13.41 +*}
13.42 +ML {*
13.43 + TPTP_Parser.parse_expression ""
13.44 + ("fof(dt_k4_waybel34,axiom,(" ^
13.45 + "! [A] :" ^
13.46 + "( ~ v1_xboole_0(A)" ^
13.47 + "=> ( ~ v3_struct_0(k4_waybel34(A))" ^
13.48 + "& v2_altcat_1(k4_waybel34(A))" ^
13.49 + "& v6_altcat_1(k4_waybel34(A))" ^
13.50 + "& v11_altcat_1(k4_waybel34(A))" ^
13.51 + "& v12_altcat_1(k4_waybel34(A))" ^
13.52 + "& v2_yellow21(k4_waybel34(A))" ^
13.53 + "& l2_altcat_1(k4_waybel34(A)) ) ) )).")
13.54 +*}
13.55 +
13.56 +ML {*
13.57 +open TPTP_Syntax;
13.58 +@{assert}
13.59 + ((TPTP_Parser.parse_expression ""
13.60 + "thf(x,axiom,^ [X] : ^ [Y] : f @ g)."
13.61 + |> payloads_of |> hd)
13.62 + =
13.63 + Fmla (Interpreted_ExtraLogic Apply,
13.64 + [Quant (Lambda, [("X", NONE)],
13.65 + Quant (Lambda, [("Y", NONE)],
13.66 + Atom (THF_Atom_term (Term_Func (Uninterpreted "f", []))))),
13.67 + Atom (THF_Atom_term (Term_Func (Uninterpreted "g", [])))])
13.68 +)
13.69 +*}
13.70 +
13.71 +
13.72 +section "Source problems"
13.73 +ML {*
13.74 + (*problem source*)
13.75 + val thf_probs_dir =
13.76 + Path.explode "$TPTP_PROBLEMS_PATH"
13.77 + |> Path.expand;
13.78 +
13.79 + (*list of files to under test*)
13.80 + val files = TPTP_Syntax.get_file_list thf_probs_dir;
13.81 +
13.82 +(* (*test problem-name parsing and mangling*)
13.83 + val problem_names =
13.84 + map (Path.base #>
13.85 + Path.implode #>
13.86 + TPTP_Problem_Name.parse_problem_name #>
13.87 + TPTP_Problem_Name.mangle_problem_name)
13.88 + files*)
13.89 +*}
13.90 +
13.91 +
13.92 +section "Supporting test functions"
13.93 +ML {*
13.94 + fun report ctxt str =
13.95 + let
13.96 + val warning_out = Config.get ctxt warning_out
13.97 + in
13.98 + if warning_out = "" then warning str
13.99 + else
13.100 + let
13.101 + val out_stream = TextIO.openAppend warning_out
13.102 + in (TextIO.output (out_stream, str ^ "\n");
13.103 + TextIO.flushOut out_stream;
13.104 + TextIO.closeOut out_stream)
13.105 + end
13.106 + end
13.107 +
13.108 + fun test_fn ctxt f msg default_val file_name =
13.109 + let
13.110 + val _ = TPTP_Syntax.debug tracing (msg ^ " " ^ Path.print file_name)
13.111 + in
13.112 + (f file_name; ())
13.113 + (*otherwise report exceptions as warnings*)
13.114 + handle exn =>
13.115 + if Exn.is_interrupt exn then
13.116 + reraise exn
13.117 + else
13.118 + (report ctxt (msg ^ " test: file " ^ Path.print file_name ^
13.119 + " raised exception: " ^ ML_Compiler.exn_message exn);
13.120 + default_val)
13.121 + end
13.122 +
13.123 + fun timed_test ctxt f =
13.124 + let
13.125 + fun f' x = (f x; ())
13.126 + val time =
13.127 + Timing.timing (List.app f') files
13.128 + |> fst
13.129 + val duration =
13.130 + #elapsed time
13.131 + |> Time.toSeconds
13.132 + |> Real.fromLargeInt
13.133 + val average =
13.134 + (StringCvt.FIX (SOME 3),
13.135 + (duration / Real.fromInt (length files)))
13.136 + |-> Real.fmt
13.137 + in
13.138 + report ctxt ("Test timing: " ^ Timing.message time ^ "\n(about " ^ average ^
13.139 + "s per problem)")
13.140 + end
13.141 +*}
13.142 +
13.143 +
13.144 +subsection "More parser tests"
13.145 +ML {*
13.146 + fun situate file_name = Path.append thf_probs_dir (Path.explode file_name);
13.147 + fun parser_test ctxt = (*FIXME argument order*)
13.148 + test_fn ctxt
13.149 + (fn file_name =>
13.150 + Path.implode file_name
13.151 + |> (fn file =>
13.152 + ((*report ctxt file; this is if you want the filename in the log*)
13.153 + TPTP_Parser.parse_file file)))
13.154 + "parser"
13.155 + ()
13.156 +*}
13.157 +
13.158 +declare [[warning_out = ""]]
13.159 +
13.160 +text "Parse a specific problem."
13.161 +ML {*
13.162 + map TPTP_Parser.parse_file
13.163 + ["$TPTP_PROBLEMS_PATH/FLD/FLD051-1.p",
13.164 + "$TPTP_PROBLEMS_PATH/FLD/FLD005-3.p",
13.165 + "$TPTP_PROBLEMS_PATH/SWV/SWV567-1.015.p",
13.166 + "$TPTP_PROBLEMS_PATH/SWV/SWV546-1.010.p"]
13.167 +*}
13.168 +ML {*
13.169 + parser_test @{context} (situate "DAT/DAT001=1.p");
13.170 + parser_test @{context} (situate "ALG/ALG001^5.p");
13.171 + parser_test @{context} (situate "NUM/NUM021^1.p");
13.172 + parser_test @{context} (situate "SYN/SYN000^1.p")
13.173 +*}
13.174 +
13.175 +text "Run the parser over all problems."
13.176 +ML {*report @{context} "Testing parser"*}
13.177 +ML {*
13.178 +(* val _ = S timed_test parser_test @{context}*)
13.179 +*}
13.180 +
13.181 +
13.182 +subsection "Interpretation"
13.183 +
13.184 +text "Interpret a problem."
13.185 +ML {*
13.186 + val (time, ((type_map, const_map, fmlas), thy)) =
13.187 + Timing.timing
13.188 + (TPTP_Interpret.interpret_file
13.189 + false
13.190 + (Path.dir thf_probs_dir)
13.191 + (Path.append thf_probs_dir (Path.explode "LCL/LCL825-1.p"))
13.192 + []
13.193 + [])
13.194 + @{theory}
13.195 +
13.196 + (*also tried
13.197 + "ALG/ALG001^5.p"
13.198 + "COM/COM003+2.p"
13.199 + "COM/COM003-1.p"
13.200 + "COM/COM024^5.p"
13.201 + "DAT/DAT017=1.p"
13.202 + "NUM/NUM021^1.p"
13.203 + "NUM/NUM858=1.p"
13.204 + "SYN/SYN000^2.p"*)
13.205 +
13.206 + (*These take too long
13.207 + "NLP/NLP562+1.p"
13.208 + "SWV/SWV546-1.010.p"
13.209 + "SWV/SWV567-1.015.p"
13.210 + "LCL/LCL680+1.020.p"*)
13.211 +*}
13.212 +
13.213 +text "... and display nicely."
13.214 +ML {*
13.215 + List.app (Pretty.writeln o (Syntax.pretty_term @{context}) o #4) fmlas
13.216 +*}
13.217 +ML {*
13.218 + (*Don't use TPTP_Syntax.string_of_tptp_formula, it's just for testing*)
13.219 + List.app (writeln o TPTP_Syntax.string_of_tptp_formula o #3) fmlas
13.220 +*}
13.221 +
13.222 +
13.223 +text "Run interpretation over all problems. This works only for logics
13.224 + for which interpretation is defined (in TPTP_Parser/tptp_interpret.ML)."
13.225 +ML {*
13.226 + report @{context} "Interpreting all problems.";
13.227 + fun interpretation_test timeout ctxt =
13.228 + test_fn ctxt
13.229 + (fn file =>
13.230 + (writeln (Path.implode file);
13.231 + TimeLimit.timeLimit (Time.fromSeconds timeout)
13.232 + (TPTP_Interpret.interpret_file
13.233 + false
13.234 + (Path.dir thf_probs_dir)
13.235 + file
13.236 + []
13.237 + [])
13.238 + @{theory}))
13.239 + "interpreter"
13.240 + ()
13.241 + val _ = S timed_test (interpretation_test 5) @{context}
13.242 +*}
13.243 +
13.244 +end
13.245 \ No newline at end of file