TSTP Solution File: SWW476+5 by Bliksem---1.12
View Problem
- Process Solution
%------------------------------------------------------------------------------
% File : Bliksem---1.12
% Problem : SWW476+5 : TPTP v8.1.0. Released v5.3.0.
% Transfm : none
% Format : tptp:raw
% Command : bliksem %s
% Computer : n027.cluster.edu
% Model : x86_64 x86_64
% CPU : Intel(R) Xeon(R) CPU E5-2620 v4 2.10GHz
% Memory : 8042.1875MB
% OS : Linux 3.10.0-693.el7.x86_64
% CPULimit : 300s
% WCLimit : 0s
% DateTime : Wed Jul 20 23:22:23 EDT 2022
% Result : Timeout 300.01s 300.41s
% Output : None
% Verified :
% SZS Type : -
% Comments :
%------------------------------------------------------------------------------
%----No solution output by system
%------------------------------------------------------------------------------
%----ORIGINAL SYSTEM OUTPUT
% 0.07/0.12 % Problem : SWW476+5 : TPTP v8.1.0. Released v5.3.0.
% 0.07/0.13 % Command : bliksem %s
% 0.12/0.34 % Computer : n027.cluster.edu
% 0.12/0.34 % Model : x86_64 x86_64
% 0.12/0.34 % CPU : Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz
% 0.12/0.34 % Memory : 8042.1875MB
% 0.12/0.34 % OS : Linux 3.10.0-693.el7.x86_64
% 0.12/0.34 % CPULimit : 300
% 0.12/0.34 % DateTime : Sat Jun 4 07:51:51 EDT 2022
% 0.12/0.34 % CPUTime :
% 1.56/1.92 *** allocated 10000 integers for termspace/termends
% 1.56/1.92 *** allocated 10000 integers for clauses
% 1.56/1.92 *** allocated 10000 integers for justifications
% 1.56/1.92 *** allocated 15000 integers for termspace/termends
% 1.56/1.92 *** allocated 22500 integers for termspace/termends
% 1.56/1.92 *** allocated 33750 integers for termspace/termends
% 1.56/1.92 Bliksem 1.12
% 1.56/1.92
% 1.56/1.92
% 1.56/1.92 Automatic Strategy Selection
% 1.56/1.92
% 1.56/1.92 *** allocated 50625 integers for termspace/termends
% 1.56/1.92 *** allocated 75937 integers for termspace/termends
% 1.56/1.92 *** allocated 113905 integers for termspace/termends
% 1.56/1.92 *** allocated 170857 integers for termspace/termends
% 1.56/1.92
% 1.56/1.92 Clauses:
% 1.56/1.92
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ) ) ), eval ) =
% 1.56/1.92 eval }.
% 1.56/1.92 { ti( fun( exp( list( char ) ), bool ), final( list( char ) ) ) = final(
% 1.56/1.92 list( char ) ) }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ) ), conf( X ) ) = conf( X ) }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), bool ) ), hconf(
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) = hconf(
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( list( char ), option( val ) ), fun( fun( list( char ), option( ty
% 1.56/1.92 ) ), bool ) ) ) ), lconf( X ) ) = lconf( X ) }.
% 1.56/1.92 { ti( fun( exp( list( char ) ), fun( list( char ), fun( list( char ), fun(
% 1.56/1.92 exp( list( char ) ), exp( list( char ) ) ) ) ) ), tryCatch( list( char )
% 1.56/1.92 ) ) = tryCatch( list( char ) ) }.
% 1.56/1.92 { ti( fun( val, exp( list( char ) ) ), val_1( list( char ) ) ) = val_1(
% 1.56/1.92 list( char ) ) }.
% 1.56/1.92 { ti( fun( fun( X, Y ), fun( fun( Z, X ), fun( Z, Y ) ) ), comp( X, Y, Z )
% 1.56/1.92 ) = comp( X, Y, Z ) }.
% 1.56/1.92 { ti( fun( fun( list( char ), option( val ) ), fun( fun( list( char ),
% 1.56/1.92 option( val ) ), fun( fun( list( char ), bool ), fun( list( char ),
% 1.56/1.92 option( val ) ) ) ) ), override_on( list( char ), option( val ) ) ) =
% 1.56/1.92 override_on( list( char ), option( val ) ) }.
% 1.56/1.92 { ti( X, undefined( X ) ) = undefined( X ) }.
% 1.56/1.92 { ti( fun( list( list( char ) ), bool ), distinct( list( char ) ) ) =
% 1.56/1.92 distinct( list( char ) ) }.
% 1.56/1.92 { ti( fun( fun( X, fun( Y, bool ) ), fun( list( X ), fun( list( Y ), bool )
% 1.56/1.92 ) ), list_all2( X, Y ) ) = list_all2( X, Y ) }.
% 1.56/1.92 { ti( fun( fun( X, Y ), fun( list( X ), list( Y ) ) ), map( X, Y ) ) = map
% 1.56/1.92 ( X, Y ) }.
% 1.56/1.92 { ti( fun( list( X ), fun( X, bool ) ), set( X ) ) = set( X ) }.
% 1.56/1.92 { ti( fun( fun( X, option( Y ) ), fun( fun( X, option( Y ) ), fun( X,
% 1.56/1.92 option( Y ) ) ) ), map_add( X, Y ) ) = map_add( X, Y ) }.
% 1.56/1.92 { ti( fun( fun( X, option( Y ) ), fun( list( X ), fun( list( Y ), fun( X,
% 1.56/1.92 option( Y ) ) ) ) ), map_upds( X, Y ) ) = map_upds( X, Y ) }.
% 1.56/1.92 { ti( fun( list( X ), nat ), size_size( list( X ) ) ) = size_size( list( X
% 1.56/1.92 ) ) }.
% 1.56/1.92 { ti( fun( fun( nat, option( product_prod( list( char ), fun( product_prod
% 1.56/1.92 ( list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool ) ), hext ) = hext }.
% 1.56/1.92 { ti( fun( fun( nat, option( product_prod( list( char ), fun( product_prod
% 1.56/1.92 ( list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, option(
% 1.56/1.92 ty ) ) ), typeof_h ) = typeof_h }.
% 1.56/1.92 { ti( fun( X, option( X ) ), some( X ) ) = some( X ) }.
% 1.56/1.92 { ti( fun( option( X ), X ), the( X ) ) = the( X ) }.
% 1.56/1.92 { ti( fun( X, fun( Y, product_prod( X, Y ) ) ), product_Pair( X, Y ) ) =
% 1.56/1.92 product_Pair( X, Y ) }.
% 1.56/1.92 { ti( fun( fun( product_prod( X, Y ), Z ), fun( X, fun( Y, Z ) ) ),
% 1.56/1.92 product_curry( X, Y, Z ) ) = product_curry( X, Y, Z ) }.
% 1.56/1.92 { ti( fun( fun( X, fun( Y, Z ) ), fun( product_prod( X, Y ), Z ) ),
% 1.56/1.92 produc1605651328_split( X, Y, Z ) ) = produc1605651328_split( X, Y, Z ) }
% 1.56/1.92 .
% 1.56/1.92 { ti( fun( fun( X, fun( Y, Z ) ), fun( product_prod( X, Y ), Z ) ),
% 1.56/1.92 product_prod_rec( X, Y, Z ) ) = product_prod_rec( X, Y, Z ) }.
% 1.56/1.92 { ti( fun( product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ) ) ), exp( list( char ) )
% 1.56/1.92 ), blocks ) = blocks }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ) ), red ) = red }.
% 1.56/1.92 { ti( fun( fun( product_prod( X, X ), bool ), fun( product_prod( X, X ),
% 1.56/1.92 bool ) ), transitive_rtrancl( X ) ) = transitive_rtrancl( X ) }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ) ), widen( X ) ) = widen( X )
% 1.56/1.92 }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ) ),
% 1.56/1.92 wTrt ) = wTrt }.
% 1.56/1.92 { ti( fun( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( ty ) ), fun( list( exp( list( char ) ) ), fun( list( ty ),
% 1.56/1.92 bool ) ) ) ) ), wTrts ) = wTrts }.
% 1.56/1.92 { ti( fun( X, fun( X, bool ) ), fequal( X ) ) = fequal( X ) }.
% 1.56/1.92 { hAPP( X, Y, ti( fun( X, Y ), Z ), T ) = hAPP( X, Y, Z, T ) }.
% 1.56/1.92 { hAPP( X, Y, Z, ti( X, T ) ) = hAPP( X, Y, Z, T ) }.
% 1.56/1.92 { ti( X, hAPP( Y, X, Z, T ) ) = hAPP( Y, X, Z, T ) }.
% 1.56/1.92 { ! hBOOL( ti( bool, X ) ), hBOOL( X ) }.
% 1.56/1.92 { ! hBOOL( X ), hBOOL( ti( bool, X ) ) }.
% 1.56/1.92 { ti( fun( X, fun( fun( X, bool ), bool ) ), member( X ) ) = member( X ) }
% 1.56/1.92 .
% 1.56/1.92 { ti( fun( list( char ), option( ty ) ), e_1 ) = e_1 }.
% 1.56/1.92 { ti( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , p ) = p }.
% 1.56/1.92 { ti( ty, t ) = t }.
% 1.56/1.92 { ti( list( ty ), ts ) = ts }.
% 1.56/1.92 { ti( list( list( char ) ), vs_1 ) = vs_1 }.
% 1.56/1.92 { ti( exp( list( char ) ), e ) = e }.
% 1.56/1.92 { ti( fun( nat, option( product_prod( list( char ), fun( product_prod( list
% 1.56/1.92 ( char ), list( char ) ), option( val ) ) ) ) ), h ) = h }.
% 1.56/1.92 { ti( list( val ), vs ) = vs }.
% 1.56/1.92 { hBOOL( hAPP( list( ty ), bool, hAPP( list( ty ), fun( list( ty ), bool )
% 1.56/1.92 , hAPP( fun( ty, fun( ty, bool ) ), fun( list( ty ), fun( list( ty ),
% 1.56/1.92 bool ) ), list_all2( ty, ty ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, X ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X
% 1.56/1.92 ), Y ) ), Z ), Z ) ) }.
% 1.56/1.92 { hBOOL( hAPP( ty, bool, hAPP( ty, fun( ty, bool ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 ty, fun( ty, bool ) ), widen( X ), Y ), Z ), Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( ty ), fun( list( ty ), bool
% 1.56/1.92 ), hAPP( fun( ty, fun( ty, bool ) ), fun( list( ty ), fun( list( ty ),
% 1.56/1.92 bool ) ), list_all2( ty, ty ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, X ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X
% 1.56/1.92 ), Y ) ), Z ), T ) ), ! hBOOL( hAPP( list( ty ), bool, hAPP( list( ty )
% 1.56/1.92 , fun( list( ty ), bool ), hAPP( fun( ty, fun( ty, bool ) ), fun( list(
% 1.56/1.92 ty ), fun( list( ty ), bool ) ), list_all2( ty, ty ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 ty, fun( ty, bool ) ), widen( X ), Y ) ), T ), U ) ), hBOOL( hAPP( list(
% 1.56/1.92 ty ), bool, hAPP( list( ty ), fun( list( ty ), bool ), hAPP( fun( ty, fun
% 1.56/1.92 ( ty, bool ) ), fun( list( ty ), fun( list( ty ), bool ) ), list_all2( ty
% 1.56/1.92 , ty ), hAPP( list( product_prod( list( char ), product_prod( list( char
% 1.56/1.92 ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ) ), Z ), U )
% 1.56/1.92 ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ), bool ),
% 1.56/1.92 hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ), bool ) )
% 1.56/1.92 , list_all2( Y, X ), U ), Z ), T ) ), hAPP( list( Y ), nat, size_size(
% 1.56/1.92 list( Y ) ), Z ) = hAPP( list( X ), nat, size_size( list( X ) ), T ) }.
% 1.56/1.92 { hAPP( list( X ), nat, size_size( list( X ) ), hAPP( list( Y ), list( X )
% 1.56/1.92 , hAPP( fun( Y, X ), fun( list( Y ), list( X ) ), map( Y, X ), Z ), T ) )
% 1.56/1.92 = hAPP( list( Y ), nat, size_size( list( Y ) ), T ) }.
% 1.56/1.92 { ! hAPP( list( X ), list( U ), hAPP( fun( X, U ), fun( list( X ), list( U
% 1.56/1.92 ) ), map( X, U ), W ), Z ) = hAPP( list( Y ), list( U ), hAPP( fun( Y, U
% 1.56/1.92 ), fun( list( Y ), list( U ) ), map( Y, U ), V0 ), T ), hAPP( list( X )
% 1.56/1.92 , nat, size_size( list( X ) ), Z ) = hAPP( list( Y ), nat, size_size(
% 1.56/1.92 list( Y ) ), T ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, product_prod( Y, product_prod( Z,
% 1.56/1.92 product_prod( T, product_prod( U, W ) ) ) ) ), bool, V0, hAPP(
% 1.56/1.92 product_prod( Y, product_prod( Z, product_prod( T, product_prod( U, W ) )
% 1.56/1.92 ) ), product_prod( X, product_prod( Y, product_prod( Z, product_prod( T
% 1.56/1.92 , product_prod( U, W ) ) ) ) ), hAPP( X, fun( product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ),
% 1.56/1.92 product_prod( X, product_prod( Y, product_prod( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ) ) ) ), product_Pair( X, product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ) ), skol1( X
% 1.56/1.92 , Y, Z, T, U, W, V0 ) ), hAPP( product_prod( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ), product_prod( Y, product_prod( Z, product_prod
% 1.56/1.92 ( T, product_prod( U, W ) ) ) ), hAPP( Y, fun( product_prod( Z,
% 1.56/1.92 product_prod( T, product_prod( U, W ) ) ), product_prod( Y, product_prod
% 1.56/1.92 ( Z, product_prod( T, product_prod( U, W ) ) ) ) ), product_Pair( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ), skol42( X,
% 1.56/1.92 Y, Z, T, U, W, V0 ) ), hAPP( product_prod( T, product_prod( U, W ) ),
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ), hAPP( Z, fun
% 1.56/1.92 ( product_prod( T, product_prod( U, W ) ), product_prod( Z, product_prod
% 1.56/1.92 ( T, product_prod( U, W ) ) ) ), product_Pair( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ), skol66( X, Y, Z, T, U, W, V0 ) ), hAPP(
% 1.56/1.92 product_prod( U, W ), product_prod( T, product_prod( U, W ) ), hAPP( T,
% 1.56/1.92 fun( product_prod( U, W ), product_prod( T, product_prod( U, W ) ) ),
% 1.56/1.92 product_Pair( T, product_prod( U, W ) ), skol81( X, Y, Z, T, U, W, V0 ) )
% 1.56/1.92 , hAPP( W, product_prod( U, W ), hAPP( U, fun( W, product_prod( U, W ) )
% 1.56/1.92 , product_Pair( U, W ), skol89( X, Y, Z, T, U, W, V0 ) ), skol93( X, Y, Z
% 1.56/1.92 , T, U, W, V0 ) ) ) ) ) ) ) ), hBOOL( hAPP( product_prod( X, product_prod
% 1.56/1.92 ( Y, product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ) ), bool
% 1.56/1.92 , V0, V1 ) ) }.
% 1.56/1.92 { ti( product_prod( X, product_prod( Y, product_prod( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ) ) ), V0 ) = hAPP( product_prod( Y, product_prod
% 1.56/1.92 ( Z, product_prod( T, product_prod( U, W ) ) ) ), product_prod( X,
% 1.56/1.92 product_prod( Y, product_prod( Z, product_prod( T, product_prod( U, W ) )
% 1.56/1.92 ) ) ), hAPP( X, fun( product_prod( Y, product_prod( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ) ), product_prod( X, product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ) ) ),
% 1.56/1.92 product_Pair( X, product_prod( Y, product_prod( Z, product_prod( T,
% 1.56/1.92 product_prod( U, W ) ) ) ) ), skol2( X, Y, Z, T, U, W, V0 ) ), hAPP(
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ), product_prod
% 1.56/1.92 ( Y, product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ), hAPP(
% 1.56/1.92 Y, fun( product_prod( Z, product_prod( T, product_prod( U, W ) ) ),
% 1.56/1.92 product_prod( Y, product_prod( Z, product_prod( T, product_prod( U, W ) )
% 1.56/1.92 ) ) ), product_Pair( Y, product_prod( Z, product_prod( T, product_prod(
% 1.56/1.92 U, W ) ) ) ), skol43( X, Y, Z, T, U, W, V0 ) ), hAPP( product_prod( T,
% 1.56/1.92 product_prod( U, W ) ), product_prod( Z, product_prod( T, product_prod( U
% 1.56/1.92 , W ) ) ), hAPP( Z, fun( product_prod( T, product_prod( U, W ) ),
% 1.56/1.92 product_prod( Z, product_prod( T, product_prod( U, W ) ) ) ),
% 1.56/1.92 product_Pair( Z, product_prod( T, product_prod( U, W ) ) ), skol67( X, Y
% 1.56/1.92 , Z, T, U, W, V0 ) ), hAPP( product_prod( U, W ), product_prod( T,
% 1.56/1.92 product_prod( U, W ) ), hAPP( T, fun( product_prod( U, W ), product_prod
% 1.56/1.92 ( T, product_prod( U, W ) ) ), product_Pair( T, product_prod( U, W ) ),
% 1.56/1.92 skol82( X, Y, Z, T, U, W, V0 ) ), hAPP( W, product_prod( U, W ), hAPP( U
% 1.56/1.92 , fun( W, product_prod( U, W ) ), product_Pair( U, W ), skol90( X, Y, Z,
% 1.56/1.92 T, U, W, V0 ) ), skol94( X, Y, Z, T, U, W, V0 ) ) ) ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, product_prod( Y, product_prod( Z,
% 1.56/1.92 product_prod( T, U ) ) ) ), bool, W, hAPP( product_prod( Y, product_prod
% 1.56/1.92 ( Z, product_prod( T, U ) ) ), product_prod( X, product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ) ), hAPP( X, fun( product_prod(
% 1.56/1.92 Y, product_prod( Z, product_prod( T, U ) ) ), product_prod( X,
% 1.56/1.92 product_prod( Y, product_prod( Z, product_prod( T, U ) ) ) ) ),
% 1.56/1.92 product_Pair( X, product_prod( Y, product_prod( Z, product_prod( T, U ) )
% 1.56/1.92 ) ), skol3( X, Y, Z, T, U, W ) ), hAPP( product_prod( Z, product_prod( T
% 1.56/1.92 , U ) ), product_prod( Y, product_prod( Z, product_prod( T, U ) ) ), hAPP
% 1.56/1.92 ( Y, fun( product_prod( Z, product_prod( T, U ) ), product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ) ), product_Pair( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ), skol44( X, Y, Z, T, U, W ) ),
% 1.56/1.92 hAPP( product_prod( T, U ), product_prod( Z, product_prod( T, U ) ), hAPP
% 1.56/1.92 ( Z, fun( product_prod( T, U ), product_prod( Z, product_prod( T, U ) ) )
% 1.56/1.92 , product_Pair( Z, product_prod( T, U ) ), skol68( X, Y, Z, T, U, W ) ),
% 1.56/1.92 hAPP( U, product_prod( T, U ), hAPP( T, fun( U, product_prod( T, U ) ),
% 1.56/1.92 product_Pair( T, U ), skol83( X, Y, Z, T, U, W ) ), skol91( X, Y, Z, T, U
% 1.56/1.92 , W ) ) ) ) ) ) ), hBOOL( hAPP( product_prod( X, product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ) ), bool, W, V0 ) ) }.
% 1.56/1.92 { ti( product_prod( X, product_prod( Y, product_prod( Z, product_prod( T, U
% 1.56/1.92 ) ) ) ), W ) = hAPP( product_prod( Y, product_prod( Z, product_prod( T,
% 1.56/1.92 U ) ) ), product_prod( X, product_prod( Y, product_prod( Z, product_prod
% 1.56/1.92 ( T, U ) ) ) ), hAPP( X, fun( product_prod( Y, product_prod( Z,
% 1.56/1.92 product_prod( T, U ) ) ), product_prod( X, product_prod( Y, product_prod
% 1.56/1.92 ( Z, product_prod( T, U ) ) ) ) ), product_Pair( X, product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ) ), skol4( X, Y, Z, T, U, W ) )
% 1.56/1.92 , hAPP( product_prod( Z, product_prod( T, U ) ), product_prod( Y,
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ) ), hAPP( Y, fun( product_prod( Z
% 1.56/1.92 , product_prod( T, U ) ), product_prod( Y, product_prod( Z, product_prod
% 1.56/1.92 ( T, U ) ) ) ), product_Pair( Y, product_prod( Z, product_prod( T, U ) )
% 1.56/1.92 ), skol45( X, Y, Z, T, U, W ) ), hAPP( product_prod( T, U ),
% 1.56/1.92 product_prod( Z, product_prod( T, U ) ), hAPP( Z, fun( product_prod( T, U
% 1.56/1.92 ), product_prod( Z, product_prod( T, U ) ) ), product_Pair( Z,
% 1.56/1.92 product_prod( T, U ) ), skol69( X, Y, Z, T, U, W ) ), hAPP( U,
% 1.56/1.92 product_prod( T, U ), hAPP( T, fun( U, product_prod( T, U ) ),
% 1.56/1.92 product_Pair( T, U ), skol84( X, Y, Z, T, U, W ) ), skol92( X, Y, Z, T, U
% 1.56/1.92 , W ) ) ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, product_prod( Y, product_prod( Z, T ) ) )
% 1.56/1.92 , bool, U, hAPP( product_prod( Y, product_prod( Z, T ) ), product_prod( X
% 1.56/1.92 , product_prod( Y, product_prod( Z, T ) ) ), hAPP( X, fun( product_prod(
% 1.56/1.92 Y, product_prod( Z, T ) ), product_prod( X, product_prod( Y, product_prod
% 1.56/1.92 ( Z, T ) ) ) ), product_Pair( X, product_prod( Y, product_prod( Z, T ) )
% 1.56/1.92 ), skol5( X, Y, Z, T, U ) ), hAPP( product_prod( Z, T ), product_prod( Y
% 1.56/1.92 , product_prod( Z, T ) ), hAPP( Y, fun( product_prod( Z, T ),
% 1.56/1.92 product_prod( Y, product_prod( Z, T ) ) ), product_Pair( Y, product_prod
% 1.56/1.92 ( Z, T ) ), skol46( X, Y, Z, T, U ) ), hAPP( T, product_prod( Z, T ),
% 1.56/1.92 hAPP( Z, fun( T, product_prod( Z, T ) ), product_Pair( Z, T ), skol70( X
% 1.56/1.92 , Y, Z, T, U ) ), skol85( X, Y, Z, T, U ) ) ) ) ) ), hBOOL( hAPP(
% 1.56/1.92 product_prod( X, product_prod( Y, product_prod( Z, T ) ) ), bool, U, W )
% 1.56/1.92 ) }.
% 1.56/1.92 { ti( product_prod( X, product_prod( Y, product_prod( Z, T ) ) ), U ) =
% 1.56/1.92 hAPP( product_prod( Y, product_prod( Z, T ) ), product_prod( X,
% 1.56/1.92 product_prod( Y, product_prod( Z, T ) ) ), hAPP( X, fun( product_prod( Y
% 1.56/1.92 , product_prod( Z, T ) ), product_prod( X, product_prod( Y, product_prod
% 1.56/1.92 ( Z, T ) ) ) ), product_Pair( X, product_prod( Y, product_prod( Z, T ) )
% 1.56/1.92 ), skol6( X, Y, Z, T, U ) ), hAPP( product_prod( Z, T ), product_prod( Y
% 1.56/1.92 , product_prod( Z, T ) ), hAPP( Y, fun( product_prod( Z, T ),
% 1.56/1.92 product_prod( Y, product_prod( Z, T ) ) ), product_Pair( Y, product_prod
% 1.56/1.92 ( Z, T ) ), skol47( X, Y, Z, T, U ) ), hAPP( T, product_prod( Z, T ),
% 1.56/1.92 hAPP( Z, fun( T, product_prod( Z, T ) ), product_Pair( Z, T ), skol71( X
% 1.56/1.92 , Y, Z, T, U ) ), skol86( X, Y, Z, T, U ) ) ) ) }.
% 1.56/1.92 { ! hAPP( X, product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) )
% 1.56/1.92 , product_Pair( Y, X ), Z ), T ) = hAPP( X, product_prod( Y, X ), hAPP( Y
% 1.56/1.92 , fun( X, product_prod( Y, X ) ), product_Pair( Y, X ), U ), W ), ti( Y,
% 1.56/1.92 Z ) = ti( Y, U ) }.
% 1.56/1.92 { ! hAPP( X, product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) )
% 1.56/1.92 , product_Pair( Y, X ), Z ), T ) = hAPP( X, product_prod( Y, X ), hAPP( Y
% 1.56/1.92 , fun( X, product_prod( Y, X ) ), product_Pair( Y, X ), U ), W ), ti( X,
% 1.56/1.92 T ) = ti( X, W ) }.
% 1.56/1.92 { ! hAPP( X, product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) )
% 1.56/1.92 , product_Pair( Y, X ), Z ), T ) = hAPP( X, product_prod( Y, X ), hAPP( Y
% 1.56/1.92 , fun( X, product_prod( Y, X ) ), product_Pair( Y, X ), U ), W ), ti( Y,
% 1.56/1.92 Z ) = ti( Y, U ) }.
% 1.56/1.92 { ! hAPP( X, product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) )
% 1.56/1.92 , product_Pair( Y, X ), Z ), T ) = hAPP( X, product_prod( Y, X ), hAPP( Y
% 1.56/1.92 , fun( X, product_prod( Y, X ) ), product_Pair( Y, X ), U ), W ), ti( X,
% 1.56/1.92 T ) = ti( X, W ) }.
% 1.56/1.92 { ! ti( Y, Z ) = ti( Y, U ), ! ti( X, T ) = ti( X, W ), hAPP( X,
% 1.56/1.92 product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) ),
% 1.56/1.92 product_Pair( Y, X ), Z ), T ) = hAPP( X, product_prod( Y, X ), hAPP( Y,
% 1.56/1.92 fun( X, product_prod( Y, X ) ), product_Pair( Y, X ), U ), W ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, Y ), bool, Z, skol7( X, Y, Z ) ) ), hBOOL
% 1.56/1.92 ( hAPP( product_prod( X, Y ), bool, Z, hAPP( Y, product_prod( X, Y ),
% 1.56/1.92 hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), T ), U ) )
% 1.56/1.92 ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, Y ), bool, Z, hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol48
% 1.56/1.92 ( X, Y, Z ) ), skol72( X, Y, Z ) ) ) ), hBOOL( hAPP( product_prod( X, Y )
% 1.56/1.92 , bool, Z, T ) ) }.
% 1.56/1.92 { hAPP( list( Z ), nat, size_size( list( Z ) ), X ) = hAPP( list( Z ), nat
% 1.56/1.92 , size_size( list( Z ) ), Y ), ! X = Y }.
% 1.56/1.92 { ! Y = Z, hBOOL( hAPP( list( X ), bool, hAPP( list( X ), fun( list( X ),
% 1.56/1.92 bool ), hAPP( fun( X, fun( X, bool ) ), fun( list( X ), fun( list( X ),
% 1.56/1.92 bool ) ), list_all2( X, X ), fequal( X ) ), Y ), Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( X ), bool, hAPP( list( X ), fun( list( X ), bool ),
% 1.56/1.92 hAPP( fun( X, fun( X, bool ) ), fun( list( X ), fun( list( X ), bool ) )
% 1.56/1.92 , list_all2( X, X ), fequal( X ) ), Y ), Z ) ), Y = Z }.
% 1.56/1.92 { ! hBOOL( hAPP( ty, bool, hAPP( ty, fun( ty, bool ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 ty, fun( ty, bool ) ), widen( X ), Y ), Z ), T ) ), ! hBOOL( hAPP( ty,
% 1.56/1.92 bool, hAPP( ty, fun( ty, bool ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, X ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X
% 1.56/1.92 ), Y ), T ), U ) ), hBOOL( hAPP( ty, bool, hAPP( ty, fun( ty, bool ),
% 1.56/1.92 hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ), Z ), U ) )
% 1.56/1.92 }.
% 1.56/1.92 { ti( product_prod( X, product_prod( Y, Z ) ), T ) = hAPP( product_prod( Y
% 1.56/1.92 , Z ), product_prod( X, product_prod( Y, Z ) ), hAPP( X, fun(
% 1.56/1.92 product_prod( Y, Z ), product_prod( X, product_prod( Y, Z ) ) ),
% 1.56/1.92 product_Pair( X, product_prod( Y, Z ) ), skol8( X, Y, Z, T ) ), hAPP( Z,
% 1.56/1.92 product_prod( Y, Z ), hAPP( Y, fun( Z, product_prod( Y, Z ) ),
% 1.56/1.92 product_Pair( Y, Z ), skol49( X, Y, Z, T ) ), skol73( X, Y, Z, T ) ) ) }
% 1.56/1.92 .
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, product_prod( Y, Z ) ), bool, T, hAPP(
% 1.56/1.92 product_prod( Y, Z ), product_prod( X, product_prod( Y, Z ) ), hAPP( X,
% 1.56/1.92 fun( product_prod( Y, Z ), product_prod( X, product_prod( Y, Z ) ) ),
% 1.56/1.92 product_Pair( X, product_prod( Y, Z ) ), skol9( X, Y, Z, T ) ), hAPP( Z,
% 1.56/1.92 product_prod( Y, Z ), hAPP( Y, fun( Z, product_prod( Y, Z ) ),
% 1.56/1.92 product_Pair( Y, Z ), skol50( X, Y, Z, T ) ), skol74( X, Y, Z, T ) ) ) )
% 1.56/1.92 ), hBOOL( hAPP( product_prod( X, product_prod( Y, Z ) ), bool, T, U ) )
% 1.56/1.92 }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ), bool
% 1.56/1.92 ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list( ty )
% 1.56/1.92 , bool ) ), list_all2( val, ty ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ) ),
% 1.56/1.92 conf( X ), Y ), Z ) ), T ), U ) ), hAPP( list( val ), list( option( ty )
% 1.56/1.92 ), hAPP( fun( val, option( ty ) ), fun( list( val ), list( option( ty )
% 1.56/1.92 ) ), map( val, option( ty ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, option( ty ) ), typeof_h, Z ) ), T ) = hAPP(
% 1.56/1.92 list( ty ), list( option( ty ) ), hAPP( fun( ty, option( ty ) ), fun(
% 1.56/1.92 list( ty ), list( option( ty ) ) ), map( ty, option( ty ) ), some( ty ) )
% 1.56/1.92 , skol10( W, V0, Z, T, V1 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ), bool
% 1.56/1.92 ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list( ty )
% 1.56/1.92 , bool ) ), list_all2( val, ty ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ) ),
% 1.56/1.92 conf( X ), Y ), Z ) ), T ), U ) ), hBOOL( hAPP( list( ty ), bool, hAPP(
% 1.56/1.92 list( ty ), fun( list( ty ), bool ), hAPP( fun( ty, fun( ty, bool ) ),
% 1.56/1.92 fun( list( ty ), fun( list( ty ), bool ) ), list_all2( ty, ty ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ) ), skol10(
% 1.56/1.92 X, Y, Z, T, U ) ), U ) ) }.
% 1.56/1.92 { ! hAPP( list( val ), list( option( ty ) ), hAPP( fun( val, option( ty ) )
% 1.56/1.92 , fun( list( val ), list( option( ty ) ) ), map( val, option( ty ) ),
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, option( ty
% 1.56/1.92 ) ), typeof_h, Z ) ), T ) = hAPP( list( ty ), list( option( ty ) ), hAPP
% 1.56/1.92 ( fun( ty, option( ty ) ), fun( list( ty ), list( option( ty ) ) ), map(
% 1.56/1.92 ty, option( ty ) ), some( ty ) ), W ), ! hBOOL( hAPP( list( ty ), bool,
% 1.56/1.92 hAPP( list( ty ), fun( list( ty ), bool ), hAPP( fun( ty, fun( ty, bool )
% 1.56/1.92 ), fun( list( ty ), fun( list( ty ), bool ) ), list_all2( ty, ty ), hAPP
% 1.56/1.92 ( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ) ), W ), U )
% 1.56/1.92 ), hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ),
% 1.56/1.92 bool ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list(
% 1.56/1.92 ty ), bool ) ), list_all2( val, ty ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool )
% 1.56/1.92 ) ), conf( X ), Y ), Z ) ), T ), U ) ) }.
% 1.56/1.92 { hAPP( product_prod( X, Y ), Z, hAPP( fun( X, fun( Y, Z ) ), fun(
% 1.56/1.92 product_prod( X, Y ), Z ), product_prod_rec( X, Y, Z ), T ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), U ), W ) ) = hAPP( Y, Z, hAPP( X, fun( Y, Z ), T, U
% 1.56/1.92 ), W ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ), bool ),
% 1.56/1.92 hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ), bool ) )
% 1.56/1.92 , list_all2( Y, X ), Z ), T ), U ) ), hBOOL( hAPP( X, bool, hAPP( Y, fun
% 1.56/1.92 ( X, bool ), Z, skol11( X, Y, Z, W ) ), skol51( X, Y, Z, W ) ) ), hBOOL(
% 1.56/1.92 hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ), bool ), hAPP( fun
% 1.56/1.92 ( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ), bool ) ),
% 1.56/1.92 list_all2( Y, X ), W ), T ), U ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ), bool ),
% 1.56/1.92 hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ), bool ) )
% 1.56/1.92 , list_all2( Y, X ), Z ), T ), U ) ), ! hBOOL( hAPP( X, bool, hAPP( Y,
% 1.56/1.92 fun( X, bool ), W, skol11( X, Y, Z, W ) ), skol51( X, Y, Z, W ) ) ),
% 1.56/1.92 hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ), bool ),
% 1.56/1.92 hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ), bool ) )
% 1.56/1.92 , list_all2( Y, X ), W ), T ), U ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ), Y, skol12( X, Y ) ),
% 1.56/1.92 skol12( X, Y ) ) ), hBOOL( hAPP( list( X ), bool, hAPP( list( X ), fun(
% 1.56/1.92 list( X ), bool ), hAPP( fun( X, fun( X, bool ) ), fun( list( X ), fun(
% 1.56/1.92 list( X ), bool ) ), list_all2( X, X ), Y ), Z ), Z ) ) }.
% 1.56/1.92 { hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ), Z, skol13( X, Y, Z ) ),
% 1.56/1.92 skol52( X, Y, Z ) ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( X ),
% 1.56/1.92 fun( list( X ), bool ), hAPP( fun( X, fun( X, bool ) ), fun( list( X ),
% 1.56/1.92 fun( list( X ), bool ) ), list_all2( X, X ), Z ), T ), U ) ), ! hBOOL(
% 1.56/1.92 hAPP( list( X ), bool, hAPP( list( X ), fun( list( X ), bool ), hAPP( fun
% 1.56/1.92 ( X, fun( X, bool ) ), fun( list( X ), fun( list( X ), bool ) ),
% 1.56/1.92 list_all2( X, X ), Y ), U ), T ) ), T = U }.
% 1.56/1.92 { hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ), Y, skol52( X, Y, Z ) ),
% 1.56/1.92 skol13( X, Y, Z ) ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( X ),
% 1.56/1.92 fun( list( X ), bool ), hAPP( fun( X, fun( X, bool ) ), fun( list( X ),
% 1.56/1.92 fun( list( X ), bool ) ), list_all2( X, X ), Z ), T ), U ) ), ! hBOOL(
% 1.56/1.92 hAPP( list( X ), bool, hAPP( list( X ), fun( list( X ), bool ), hAPP( fun
% 1.56/1.92 ( X, fun( X, bool ) ), fun( list( X ), fun( list( X ), bool ) ),
% 1.56/1.92 list_all2( X, X ), Y ), U ), T ) ), T = U }.
% 1.56/1.92 { ! ti( X, skol13( X, Y, Z ) ) = ti( X, skol52( X, Y, Z ) ), ! hBOOL( hAPP
% 1.56/1.92 ( list( X ), bool, hAPP( list( X ), fun( list( X ), bool ), hAPP( fun( X
% 1.56/1.92 , fun( X, bool ) ), fun( list( X ), fun( list( X ), bool ) ), list_all2(
% 1.56/1.92 X, X ), Z ), T ), U ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( X )
% 1.56/1.92 , fun( list( X ), bool ), hAPP( fun( X, fun( X, bool ) ), fun( list( X )
% 1.56/1.92 , fun( list( X ), bool ) ), list_all2( X, X ), Y ), U ), T ) ), T = U }.
% 1.56/1.92 { hBOOL( hAPP( Y, bool, hAPP( Z, fun( Y, bool ), W, skol14( X, Y, Z, T, U,
% 1.56/1.92 W ) ), skol53( X, Y, Z, T, U, W ) ) ), ! hBOOL( hAPP( list( Y ), bool,
% 1.56/1.92 hAPP( list( Z ), fun( list( Y ), bool ), hAPP( fun( Z, fun( Y, bool ) ),
% 1.56/1.92 fun( list( Z ), fun( list( Y ), bool ) ), list_all2( Z, Y ), W ), V0 ),
% 1.56/1.92 V1 ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ),
% 1.56/1.92 bool ), hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ),
% 1.56/1.92 bool ) ), list_all2( Y, X ), U ), V1 ), V2 ) ), hBOOL( hAPP( list( X ),
% 1.56/1.92 bool, hAPP( list( Z ), fun( list( X ), bool ), hAPP( fun( Z, fun( X, bool
% 1.56/1.92 ) ), fun( list( Z ), fun( list( X ), bool ) ), list_all2( Z, X ), T ),
% 1.56/1.92 V0 ), V2 ) ) }.
% 1.56/1.92 { hBOOL( hAPP( X, bool, hAPP( Y, fun( X, bool ), U, skol53( X, Y, Z, T, U,
% 1.56/1.92 W ) ), skol75( X, Y, Z, T, U, W ) ) ), ! hBOOL( hAPP( list( Y ), bool,
% 1.56/1.92 hAPP( list( Z ), fun( list( Y ), bool ), hAPP( fun( Z, fun( Y, bool ) ),
% 1.56/1.92 fun( list( Z ), fun( list( Y ), bool ) ), list_all2( Z, Y ), W ), V0 ),
% 1.56/1.92 V1 ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ),
% 1.56/1.92 bool ), hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ),
% 1.56/1.92 bool ) ), list_all2( Y, X ), U ), V1 ), V2 ) ), hBOOL( hAPP( list( X ),
% 1.56/1.92 bool, hAPP( list( Z ), fun( list( X ), bool ), hAPP( fun( Z, fun( X, bool
% 1.56/1.92 ) ), fun( list( Z ), fun( list( X ), bool ) ), list_all2( Z, X ), T ),
% 1.56/1.92 V0 ), V2 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( X, bool, hAPP( Z, fun( X, bool ), T, skol14( X, Y, Z, T, U
% 1.56/1.92 , W ) ), skol75( X, Y, Z, T, U, W ) ) ), ! hBOOL( hAPP( list( Y ), bool,
% 1.56/1.92 hAPP( list( Z ), fun( list( Y ), bool ), hAPP( fun( Z, fun( Y, bool ) ),
% 1.56/1.92 fun( list( Z ), fun( list( Y ), bool ) ), list_all2( Z, Y ), W ), V0 ),
% 1.56/1.92 V1 ) ), ! hBOOL( hAPP( list( X ), bool, hAPP( list( Y ), fun( list( X ),
% 1.56/1.92 bool ), hAPP( fun( Y, fun( X, bool ) ), fun( list( Y ), fun( list( X ),
% 1.56/1.92 bool ) ), list_all2( Y, X ), U ), V1 ), V2 ) ), hBOOL( hAPP( list( X ),
% 1.56/1.92 bool, hAPP( list( Z ), fun( list( X ), bool ), hAPP( fun( Z, fun( X, bool
% 1.56/1.92 ) ), fun( list( Z ), fun( list( X ), bool ) ), list_all2( Z, X ), T ),
% 1.56/1.92 V0 ), V2 ) ) }.
% 1.56/1.92 { hAPP( list( X ), nat, size_size( list( X ) ), skol15( X, Y ) ) = Y }.
% 1.56/1.92 { ! hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), T ), U ) ), ! hBOOL(
% 1.56/1.92 hAPP( ty, bool, hAPP( ty, fun( ty, bool ), hAPP( list( product_prod( list
% 1.56/1.92 ( char ), product_prod( list( char ), product_prod( list( product_prod(
% 1.56/1.92 list( char ), ty ) ), list( product_prod( list( char ), product_prod(
% 1.56/1.92 list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool )
% 1.56/1.92 ), widen( X ), Y ), U ), W ) ), hBOOL( hAPP( ty, bool, hAPP( val, fun(
% 1.56/1.92 ty, bool ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 val, fun( ty, bool ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod
% 1.56/1.92 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), T ), W
% 1.56/1.92 ) ) }.
% 1.56/1.92 { ! hAPP( val, option( ty ), hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( val, option( ty ) ), typeof_h, X ), Y ) = hAPP( ty, option(
% 1.56/1.92 ty ), some( ty ), Z ), hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool )
% 1.56/1.92 , hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty,
% 1.56/1.92 bool ) ), hAPP( list( product_prod( list( char ), product_prod( list(
% 1.56/1.92 char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, T
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ), conf( T ), U ), X ), Y ), Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ), bool
% 1.56/1.92 ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list( ty )
% 1.56/1.92 , bool ) ), list_all2( val, ty ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ) ),
% 1.56/1.92 conf( X ), Y ), Z ) ), T ), U ) ), ! hBOOL( hAPP( list( ty ), bool, hAPP
% 1.56/1.92 ( list( ty ), fun( list( ty ), bool ), hAPP( fun( ty, fun( ty, bool ) ),
% 1.56/1.92 fun( list( ty ), fun( list( ty ), bool ) ), list_all2( ty, ty ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ) ), U ), W )
% 1.56/1.92 ), hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ),
% 1.56/1.92 bool ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list(
% 1.56/1.92 ty ), bool ) ), list_all2( val, ty ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool )
% 1.56/1.92 ) ), conf( X ), Y ), Z ) ), T ), W ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), T ), U ) ), hAPP( val,
% 1.56/1.92 option( ty ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 val, option( ty ) ), typeof_h, Z ), T ) = hAPP( ty, option( ty ), some(
% 1.56/1.92 ty ), skol16( W, V0, Z, T, V1 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), T ), U ) ), hBOOL( hAPP
% 1.56/1.92 ( ty, bool, hAPP( ty, fun( ty, bool ), hAPP( list( product_prod( list(
% 1.56/1.92 char ), product_prod( list( char ), product_prod( list( product_prod(
% 1.56/1.92 list( char ), ty ) ), list( product_prod( list( char ), product_prod(
% 1.56/1.92 list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool )
% 1.56/1.92 ), widen( X ), Y ), skol16( X, Y, Z, T, U ) ), U ) ) }.
% 1.56/1.92 { ! hAPP( val, option( ty ), hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( val, option( ty ) ), typeof_h, Z ), T ) = hAPP( ty, option(
% 1.56/1.92 ty ), some( ty ), W ), ! hBOOL( hAPP( ty, bool, hAPP( ty, fun( ty, bool )
% 1.56/1.92 , hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen( X ), Y ), W ), U ) )
% 1.56/1.92 , hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.92 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), T ), U ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, Y ), bool, Z, T ) ), hBOOL( hAPP(
% 1.56/1.92 product_prod( X, Y ), bool, Z, hAPP( Y, product_prod( X, Y ), hAPP( X,
% 1.56/1.92 fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol17( X, Y, Z ) )
% 1.56/1.92 , skol54( X, Y, Z ) ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, Y ), bool, Z, hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), T ), U
% 1.56/1.92 ) ) ), hBOOL( hAPP( product_prod( X, Y ), bool, Z, skol76( X, Y, Z ) ) )
% 1.56/1.92 }.
% 1.56/1.92 { ti( product_prod( X, Y ), Z ) = hAPP( Y, product_prod( X, Y ), hAPP( X,
% 1.56/1.92 fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol18( X, Y, Z ) )
% 1.56/1.92 , skol55( X, Y, Z ) ) }.
% 1.56/1.92 { ti( product_prod( X, Y ), Z ) = hAPP( Y, product_prod( X, Y ), hAPP( X,
% 1.56/1.92 fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol19( X, Y, Z ) )
% 1.56/1.92 , skol56( X, Y, Z ) ) }.
% 1.56/1.92 { hAPP( product_prod( X, Y ), Z, hAPP( fun( X, fun( Y, Z ) ), fun(
% 1.56/1.92 product_prod( X, Y ), Z ), produc1605651328_split( X, Y, Z ), T ), hAPP(
% 1.56/1.92 Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), U ), W ) ) = hAPP( Y, Z, hAPP( X, fun( Y, Z ), T, U
% 1.56/1.92 ), W ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun( list( ty ), bool
% 1.56/1.92 ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val ), fun( list( ty )
% 1.56/1.92 , bool ) ), list_all2( val, ty ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ) ),
% 1.56/1.92 conf( X ), Y ), Z ) ), T ), U ) ), ! hBOOL( hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), bool, hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool )
% 1.56/1.92 , hext, Z ), W ) ), hBOOL( hAPP( list( ty ), bool, hAPP( list( val ), fun
% 1.56/1.92 ( list( ty ), bool ), hAPP( fun( val, fun( ty, bool ) ), fun( list( val )
% 1.56/1.92 , fun( list( ty ), bool ) ), list_all2( val, ty ), hAPP( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool )
% 1.56/1.92 ) ), conf( X ), Y ), W ) ), T ), U ) ) }.
% 1.56/1.92 { ! hAPP( list( list( char ) ), nat, size_size( list( list( char ) ) ), X )
% 1.56/1.92 = hAPP( list( ty ), nat, size_size( list( ty ) ), Y ), ! hAPP( list(
% 1.56/1.92 list( char ) ), nat, size_size( list( list( char ) ) ), X ) = hAPP( list
% 1.56/1.92 ( val ), nat, size_size( list( val ) ), Z ), ! hBOOL( hAPP( product_prod
% 1.56/1.92 ( fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.92 ( val ) ) ), bool, hAPP( exp( list( char ) ), fun( product_prod( fun( nat
% 1.56/1.92 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.92 list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) )
% 1.56/1.92 ), bool ), hAPP( product_prod( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( list( char ), option( val ) ) ), fun( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ), hAPP( exp( list( char ) ), fun
% 1.56/1.92 ( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ), hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, product_prod( list( list(
% 1.56/1.92 char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char ) )
% 1.56/1.92 , fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, T ), hAPP(
% 1.56/1.92 product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ) ) ), exp( list( char ) )
% 1.56/1.92 , blocks, hAPP( product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.92 ( list( char ) ) ) ), product_prod( list( list( char ) ), product_prod(
% 1.56/1.92 list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ), hAPP(
% 1.56/1.92 list( list( char ) ), fun( product_prod( list( ty ), product_prod( list(
% 1.56/1.92 val ), exp( list( char ) ) ) ), product_prod( list( list( char ) ),
% 1.56/1.92 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.92 ) ) ) ), product_Pair( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ) ) ), X ), hAPP(
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ), product_prod( list( ty
% 1.56/1.92 ), product_prod( list( val ), exp( list( char ) ) ) ), hAPP( list( ty )
% 1.56/1.92 , fun( product_prod( list( val ), exp( list( char ) ) ), product_prod(
% 1.56/1.92 list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ),
% 1.56/1.92 product_Pair( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.92 ) ), Y ), hAPP( exp( list( char ) ), product_prod( list( val ), exp(
% 1.56/1.92 list( char ) ) ), hAPP( list( val ), fun( exp( list( char ) ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ) ), product_Pair( list(
% 1.56/1.92 val ), exp( list( char ) ) ), Z ), U ) ) ) ) ), hAPP( fun( list( char ),
% 1.56/1.92 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), W ), V0
% 1.56/1.92 ) ), V1 ), hAPP( fun( list( char ), option( val ) ), product_prod( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val )
% 1.56/1.92 ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 fun( list( char ), option( val ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_Pair( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), V2 ), V3 ) ) ), hBOOL( hAPP(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, T ), U ), hAPP( fun
% 1.56/1.92 ( list( char ), option( val ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.92 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_Pair( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 W ), hAPP( list( val ), fun( list( char ), option( val ) ), hAPP( list(
% 1.56/1.92 list( char ) ), fun( list( val ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 hAPP( fun( list( char ), option( val ) ), fun( list( list( char ) ), fun
% 1.56/1.92 ( list( val ), fun( list( char ), option( val ) ) ) ), map_upds( list(
% 1.56/1.92 char ), val ), V0 ), X ), Z ) ) ), V1 ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), V2 ),
% 1.56/1.92 skol20( X, Z, T, U, W, V0, V1, V2 ) ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ), ! hBOOL(
% 1.56/1.92 hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( val, fun( ty, bool ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, Z ) ) ) ) ) ) ) ), fun(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool )
% 1.56/1.92 ) ), conf( Z ), T ), X ), U ), W ) ), hBOOL( hAPP( ty, bool, hAPP( val,
% 1.56/1.92 fun( ty, bool ), hAPP( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( val, fun( ty, bool ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, Z ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod
% 1.56/1.92 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, fun( ty, bool ) ) ), conf( Z ), T ), Y ), U ), W
% 1.56/1.92 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ), ! hAPP( val
% 1.56/1.92 , option( ty ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 val, option( ty ) ), typeof_h, X ), Z ) = hAPP( ty, option( ty ), some(
% 1.56/1.92 ty ), T ), hAPP( val, option( ty ), hAPP( fun( nat, option( product_prod
% 1.56/1.92 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( val, option( ty ) ), typeof_h, Y ), Z ) = hAPP( ty,
% 1.56/1.92 option( ty ), some( ty ), T ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char )
% 1.56/1.92 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) )
% 1.56/1.92 , fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, Z ), T ), hAPP( fun
% 1.56/1.92 ( list( char ), option( val ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.92 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_Pair( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 X ), U ) ), W ), hAPP( fun( list( char ), option( val ) ), product_prod(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.92 ( val ) ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 fun( list( char ), option( val ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_Pair( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), Y ), V0 ) ) ), hBOOL( hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool, hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), bool ), hext, X ), Y ) ) }.
% 1.56/1.92 { hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), X ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool ), hAPP
% 1.56/1.92 ( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.92 bool ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.92 bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list(
% 1.56/1.92 char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.92 , X ), Y ), Z ), T ), U ) ), ! hBOOL( hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), bool, hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool )
% 1.56/1.92 , hext, Y ), W ) ), hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun
% 1.56/1.92 ( ty, bool ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list(
% 1.56/1.92 char ) ), fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) )
% 1.56/1.92 , fun( ty, bool ) ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.92 , bool ) ) ) ), wTrt, X ), W ), Z ), T ), U ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ), ! hBOOL(
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), bool, hAPP( fun( nat
% 1.56/1.92 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.92 list( char ) ), option( val ) ) ) ) ), fun( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), bool ), hext, Y ), Z ) ), hBOOL( hAPP( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), bool, hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), bool ), hext, X ), Z ) ) }.
% 1.56/1.92 { ! hAPP( val, option( ty ), hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( val, option( ty ) ), typeof_h, X ), Y ) = hAPP( ty, option(
% 1.56/1.92 ty ), some( ty ), Z ), hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( ty, bool ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list
% 1.56/1.92 ( char ) ), fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( fun( list( char ), option( ty ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( ty, bool ) ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.92 , bool ) ) ) ), wTrt, T ), X ), U ), hAPP( val, exp( list( char ) ),
% 1.56/1.92 val_1( list( char ) ), Y ) ), Z ) ) }.
% 1.56/1.92 { ! hAPP( list( list( char ) ), nat, size_size( list( list( char ) ) ), X )
% 1.56/1.92 = hAPP( list( ty ), nat, size_size( list( ty ) ), Y ), ! hAPP( list( val
% 1.56/1.92 ), nat, size_size( list( val ) ), Z ) = hAPP( list( ty ), nat, size_size
% 1.56/1.92 ( list( ty ) ), Y ), ! hBOOL( hAPP( exp( list( char ) ), bool, final(
% 1.56/1.92 list( char ) ), T ) ), hBOOL( hAPP( fun( product_prod( product_prod( exp
% 1.56/1.92 ( list( char ) ), product_prod( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.92 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), hAPP( product_prod( list( list( char
% 1.56/1.92 ) ), product_prod( list( ty ), product_prod( list( val ), exp( list(
% 1.56/1.92 char ) ) ) ) ), exp( list( char ) ), blocks, hAPP( product_prod( list( ty
% 1.56/1.92 ), product_prod( list( val ), exp( list( char ) ) ) ), product_prod(
% 1.56/1.92 list( list( char ) ), product_prod( list( ty ), product_prod( list( val )
% 1.56/1.92 , exp( list( char ) ) ) ) ), hAPP( list( list( char ) ), fun(
% 1.56/1.92 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.92 ) ), product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ) ) ) ), product_Pair(
% 1.56/1.92 list( list( char ) ), product_prod( list( ty ), product_prod( list( val )
% 1.56/1.92 , exp( list( char ) ) ) ) ), X ), hAPP( product_prod( list( val ), exp(
% 1.56/1.92 list( char ) ) ), product_prod( list( ty ), product_prod( list( val ),
% 1.56/1.92 exp( list( char ) ) ) ), hAPP( list( ty ), fun( product_prod( list( val )
% 1.56/1.92 , exp( list( char ) ) ), product_prod( list( ty ), product_prod( list(
% 1.56/1.92 val ), exp( list( char ) ) ) ) ), product_Pair( list( ty ), product_prod
% 1.56/1.92 ( list( val ), exp( list( char ) ) ) ), Y ), hAPP( exp( list( char ) ),
% 1.56/1.92 product_prod( list( val ), exp( list( char ) ) ), hAPP( list( val ), fun
% 1.56/1.92 ( exp( list( char ) ), product_prod( list( val ), exp( list( char ) ) ) )
% 1.56/1.92 , product_Pair( list( val ), exp( list( char ) ) ), Z ), T ) ) ) ) ),
% 1.56/1.92 hAPP( fun( list( char ), option( val ) ), product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.92 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_Pair( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 U ), W ) ) ), hAPP( product_prod( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option(
% 1.56/1.92 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), U ), W ) ) ) ), hAPP( fun(
% 1.56/1.92 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.92 ), fun( product_prod( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.92 ( val ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat
% 1.56/1.92 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.92 list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) )
% 1.56/1.92 ) ) ), bool ), transitive_rtrancl( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.92 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.92 ), product_prod( ty, product_prod( list( list( char ) ), exp( list( char
% 1.56/1.92 ) ) ) ) ) ) ) ) ) ) ), fun( product_prod( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), red, V0 ) ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( exp( list( char ) ) ), fun(
% 1.56/1.92 list( ty ), bool ), hAPP( fun( list( char ), option( ty ) ), fun( list(
% 1.56/1.92 exp( list( char ) ) ), fun( list( ty ), bool ) ), hAPP( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ) ), wTrts, X )
% 1.56/1.92 , Y ), Z ), hAPP( list( val ), list( exp( list( char ) ) ), hAPP( fun(
% 1.56/1.92 val, exp( list( char ) ) ), fun( list( val ), list( exp( list( char ) ) )
% 1.56/1.92 ), map( val, exp( list( char ) ) ), val_1( list( char ) ) ), T ) ), U )
% 1.56/1.92 ), hAPP( list( val ), list( option( ty ) ), hAPP( fun( val, option( ty )
% 1.56/1.92 ), fun( list( val ), list( option( ty ) ) ), map( val, option( ty ) ),
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, option( ty
% 1.56/1.92 ) ), typeof_h, Y ) ), T ) = hAPP( list( ty ), list( option( ty ) ), hAPP
% 1.56/1.92 ( fun( ty, option( ty ) ), fun( list( ty ), list( option( ty ) ) ), map(
% 1.56/1.92 ty, option( ty ) ), some( ty ) ), U ) }.
% 1.56/1.92 { ! hAPP( list( val ), list( option( ty ) ), hAPP( fun( val, option( ty ) )
% 1.56/1.92 , fun( list( val ), list( option( ty ) ) ), map( val, option( ty ) ),
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, option( ty
% 1.56/1.92 ) ), typeof_h, Y ) ), T ) = hAPP( list( ty ), list( option( ty ) ), hAPP
% 1.56/1.92 ( fun( ty, option( ty ) ), fun( list( ty ), list( option( ty ) ) ), map(
% 1.56/1.92 ty, option( ty ) ), some( ty ) ), U ), hBOOL( hAPP( list( ty ), bool,
% 1.56/1.92 hAPP( list( exp( list( char ) ) ), fun( list( ty ), bool ), hAPP( fun(
% 1.56/1.92 list( char ), option( ty ) ), fun( list( exp( list( char ) ) ), fun( list
% 1.56/1.92 ( ty ), bool ) ), hAPP( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( list( char ), option( ty ) ), fun( list( exp( list( char ) ) ),
% 1.56/1.92 fun( list( ty ), bool ) ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( list( char ), option( ty ) ), fun( list( exp( list( char ) ) )
% 1.56/1.92 , fun( list( ty ), bool ) ) ) ), wTrts, X ), Y ), Z ), hAPP( list( val )
% 1.56/1.92 , list( exp( list( char ) ) ), hAPP( fun( val, exp( list( char ) ) ), fun
% 1.56/1.92 ( list( val ), list( exp( list( char ) ) ) ), map( val, exp( list( char )
% 1.56/1.92 ) ), val_1( list( char ) ) ), T ) ), U ) ) }.
% 1.56/1.92 { ! hAPP( X, option( X ), some( X ), Y ) = hAPP( X, option( X ), some( X )
% 1.56/1.92 , Z ), ti( X, Y ) = ti( X, Z ) }.
% 1.56/1.92 { ! ti( X, Y ) = ti( X, Z ), hAPP( X, option( X ), some( X ), Y ) = hAPP( X
% 1.56/1.92 , option( X ), some( X ), Z ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( X, Y ), bool, Z, hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), T ), U
% 1.56/1.92 ) ) ), hBOOL( hAPP( Y, bool, hAPP( X, fun( Y, bool ), hAPP( fun(
% 1.56/1.92 product_prod( X, Y ), bool ), fun( X, fun( Y, bool ) ), product_curry( X
% 1.56/1.92 , Y, bool ), Z ), T ), U ) ) }.
% 1.56/1.92 { hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, X ), hAPP( val, exp
% 1.56/1.92 ( list( char ) ), val_1( list( char ) ), Y ) ), Z ), hAPP( val, exp( list
% 1.56/1.92 ( char ) ), val_1( list( char ) ), Y ) ), Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char )
% 1.56/1.92 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) )
% 1.56/1.92 , fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, U ), hAPP( val, exp
% 1.56/1.92 ( list( char ) ), val_1( list( char ) ), X ) ), Y ), Z ), T ) ), Z = hAPP
% 1.56/1.92 ( val, exp( list( char ) ), val_1( list( char ) ), X ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char )
% 1.56/1.92 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) )
% 1.56/1.92 , fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, U ), hAPP( val, exp
% 1.56/1.92 ( list( char ) ), val_1( list( char ) ), X ) ), Y ), Z ), T ) ), T = Y }
% 1.56/1.92 .
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( exp( list( char ) ) ), fun(
% 1.56/1.92 list( ty ), bool ), hAPP( fun( list( char ), option( ty ) ), fun( list(
% 1.56/1.92 exp( list( char ) ) ), fun( list( ty ), bool ) ), hAPP( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ) ), wTrts, X )
% 1.56/1.92 , Y ), Z ), T ), U ) ), ! hBOOL( hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), bool, hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), bool ), hext, Y ), W
% 1.56/1.92 ) ), hBOOL( hAPP( list( ty ), bool, hAPP( list( exp( list( char ) ) ),
% 1.56/1.92 fun( list( ty ), bool ), hAPP( fun( list( char ), option( ty ) ), fun(
% 1.56/1.92 list( exp( list( char ) ) ), fun( list( ty ), bool ) ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) )
% 1.56/1.92 , fun( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ), hAPP(
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( ty ) ), fun( list( exp( list( char ) ) ), fun( list( ty ),
% 1.56/1.92 bool ) ) ) ), wTrts, X ), W ), Z ), T ), U ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( list( ty ), bool, hAPP( list( exp( list( char ) ) ), fun(
% 1.56/1.92 list( ty ), bool ), hAPP( fun( list( char ), option( ty ) ), fun( list(
% 1.56/1.92 exp( list( char ) ) ), fun( list( ty ), bool ) ), hAPP( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.92 ( list( exp( list( char ) ) ), fun( list( ty ), bool ) ) ) ), wTrts, Z )
% 1.56/1.92 , T ), U ), X ), Y ) ), hAPP( list( exp( list( char ) ) ), nat, size_size
% 1.56/1.92 ( list( exp( list( char ) ) ) ), X ) = hAPP( list( ty ), nat, size_size(
% 1.56/1.92 list( ty ) ), Y ) }.
% 1.56/1.92 { ! hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char )
% 1.56/1.92 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) )
% 1.56/1.92 , fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, Y ), Z ), T ), X ),
% 1.56/1.92 U ) ), hBOOL( hAPP( exp( list( char ) ), bool, final( list( char ) ), X )
% 1.56/1.92 ) }.
% 1.56/1.92 { ! hBOOL( hAPP( exp( list( char ) ), bool, final( list( char ) ), X ) ),
% 1.56/1.92 hBOOL( hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), bool, hAPP( exp( list( char ) ),
% 1.56/1.92 fun( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ), hAPP( product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 fun( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), bool ) )
% 1.56/1.92 , hAPP( exp( list( char ) ), fun( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ), bool ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( exp( list( char )
% 1.56/1.92 ), fun( product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), fun( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), bool ) ) ) ), eval, Y ), X ), Z ), X ),
% 1.56/1.92 Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( X, bool, hAPP( Y, fun( X, bool ), hAPP( fun( product_prod
% 1.56/1.92 ( Y, X ), bool ), fun( Y, fun( X, bool ) ), product_curry( Y, X, bool ),
% 1.56/1.92 Z ), T ), U ) ), hBOOL( hAPP( product_prod( Y, X ), bool, Z, hAPP( X,
% 1.56/1.92 product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) ),
% 1.56/1.92 product_Pair( Y, X ), T ), U ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( X, bool, hAPP( Y, fun( X, bool ), hAPP( fun( product_prod
% 1.56/1.92 ( Y, X ), bool ), fun( Y, fun( X, bool ) ), product_curry( Y, X, bool ),
% 1.56/1.92 Z ), T ), U ) ), hBOOL( hAPP( product_prod( Y, X ), bool, Z, hAPP( X,
% 1.56/1.92 product_prod( Y, X ), hAPP( Y, fun( X, product_prod( Y, X ) ),
% 1.56/1.92 product_Pair( Y, X ), T ), U ) ) ) }.
% 1.56/1.92 { hAPP( X, Y, hAPP( Z, fun( X, Y ), hAPP( fun( product_prod( Z, X ), Y ),
% 1.56/1.92 fun( Z, fun( X, Y ) ), product_curry( Z, X, Y ), T ), U ), W ) = hAPP(
% 1.56/1.92 product_prod( Z, X ), Y, T, hAPP( X, product_prod( Z, X ), hAPP( Z, fun(
% 1.56/1.92 X, product_prod( Z, X ) ), product_Pair( Z, X ), U ), W ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.92 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), Z ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), X ), T )
% 1.56/1.92 ) ), hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), U ), hAPP( fun( list( char ), option(
% 1.56/1.92 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), Y ), W ) ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.92 ), red, V0 ) ) ), hBOOL( hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), bool, hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ) }
% 1.56/1.92 .
% 1.56/1.92 { hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP( product_prod
% 1.56/1.92 ( X, X ), fun( fun( product_prod( X, X ), bool ), bool ), member(
% 1.56/1.92 product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X,
% 1.56/1.92 product_prod( X, X ) ), product_Pair( X, X ), Y ), Y ) ), hAPP( fun(
% 1.56/1.92 product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), Z ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), Y ), Z ) ), hBOOL( hAPP( fun(
% 1.56/1.92 product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X ), fun( fun
% 1.56/1.92 ( product_prod( X, X ), bool ), bool ), member( product_prod( X, X ) ), Y
% 1.56/1.92 ), hAPP( fun( product_prod( X, X ), bool ), fun( product_prod( X, X ),
% 1.56/1.92 bool ), transitive_rtrancl( X ), Z ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.92 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), Y ), U )
% 1.56/1.92 ) ), hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), W ), hAPP( fun( list( char ), option(
% 1.56/1.92 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), Z ), V0 ) ) ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.92 ), red, T ) ) ), ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun
% 1.56/1.92 ( ty, bool ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list(
% 1.56/1.92 char ) ), fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) )
% 1.56/1.92 , fun( ty, bool ) ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.92 , bool ) ) ) ), wTrt, T ), Y ), V1 ), X ), V2 ) ), ! hBOOL( hAPP( fun(
% 1.56/1.92 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.92 , list( char ) ), option( val ) ) ) ) ), bool, hAPP( list( product_prod(
% 1.56/1.92 list( char ), product_prod( list( char ), product_prod( list(
% 1.56/1.92 product_prod( list( char ), ty ) ), list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( ty ), product_prod( ty, product_prod( list( list(
% 1.56/1.92 char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), bool ), hconf( product_prod( list( list( char
% 1.56/1.92 ) ), exp( list( char ) ) ) ), T ), Y ) ), hBOOL( hAPP( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), bool, hAPP( list( product_prod( list( char )
% 1.56/1.92 , product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.92 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.92 ), product_prod( ty, product_prod( list( list( char ) ), exp( list( char
% 1.56/1.92 ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char )
% 1.56/1.92 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) )
% 1.56/1.92 , bool ), hconf( product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ), T ), Z ) ) }.
% 1.56/1.92 { hAPP( fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool
% 1.56/1.92 ), transitive_rtrancl( X ), hAPP( fun( product_prod( X, X ), bool ), fun
% 1.56/1.92 ( product_prod( X, X ), bool ), transitive_rtrancl( X ), Y ) ) = hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), Y ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), T ) ),
% 1.56/1.92 ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Z ), U ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), hBOOL( hAPP( fun( product_prod( X, X )
% 1.56/1.92 , bool ), bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X, X
% 1.56/1.92 ), bool ), bool ), member( product_prod( X, X ) ), hAPP( X, product_prod
% 1.56/1.92 ( X, X ), hAPP( X, fun( X, product_prod( X, X ) ), product_Pair( X, X ),
% 1.56/1.92 Y ), U ) ), hAPP( fun( product_prod( X, X ), bool ), fun( product_prod( X
% 1.56/1.92 , X ), bool ), transitive_rtrancl( X ), T ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( fun( product_prod( X, X
% 1.56/1.92 ), bool ), bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X,
% 1.56/1.92 X ), bool ), bool ), member( product_prod( X, X ) ), hAPP( X,
% 1.56/1.92 product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X ) ),
% 1.56/1.92 product_Pair( X, X ), Z ), U ) ), T ) ), hBOOL( hAPP( fun( product_prod(
% 1.56/1.92 X, X ), bool ), bool, hAPP( product_prod( X, X ), fun( fun( product_prod
% 1.56/1.92 ( X, X ), bool ), bool ), member( product_prod( X, X ) ), hAPP( X,
% 1.56/1.92 product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X ) ),
% 1.56/1.92 product_Pair( X, X ), Y ), U ) ), hAPP( fun( product_prod( X, X ), bool )
% 1.56/1.92 , fun( product_prod( X, X ), bool ), transitive_rtrancl( X ), T ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( fun( product_prod( X, X
% 1.56/1.92 ), bool ), bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X,
% 1.56/1.92 X ), bool ), bool ), member( product_prod( X, X ) ), hAPP( X,
% 1.56/1.92 product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X ) ),
% 1.56/1.92 product_Pair( X, X ), Z ), U ) ), hAPP( fun( product_prod( X, X ), bool )
% 1.56/1.92 , fun( product_prod( X, X ), bool ), transitive_rtrancl( X ), T ) ) ),
% 1.56/1.92 hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP( product_prod
% 1.56/1.92 ( X, X ), fun( fun( product_prod( X, X ), bool ), bool ), member(
% 1.56/1.92 product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X,
% 1.56/1.92 product_prod( X, X ) ), product_Pair( X, X ), Y ), U ) ), hAPP( fun(
% 1.56/1.92 product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun
% 1.56/1.92 ( Y, bool ), V1, Z ), T ) ), hBOOL( hAPP( fun( product_prod( product_prod
% 1.56/1.92 ( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), fun( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool ), member(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), product_prod( product_prod( X, Y ), product_prod( X
% 1.56/1.92 , Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X, Y ),
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), Z ), T ) ), hAPP( Y, product_prod( X, Y ), hAPP( X
% 1.56/1.92 , fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol21( X, Y, Z,
% 1.56/1.92 T, V0, V1 ) ), skol57( X, Y, Z, T, V0, V1 ) ) ) ), hAPP( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ),
% 1.56/1.92 transitive_rtrancl( product_prod( X, Y ) ), V0 ) ) ), hBOOL( hAPP( Y,
% 1.56/1.92 bool, hAPP( X, fun( Y, bool ), V1, U ), W ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun
% 1.56/1.92 ( Y, bool ), V1, Z ), T ) ), alpha3( X, Y, V0, V1, skol21( X, Y, Z, T, V0
% 1.56/1.92 , V1 ), skol57( X, Y, Z, T, V0, V1 ) ), hBOOL( hAPP( Y, bool, hAPP( X,
% 1.56/1.92 fun( Y, bool ), V1, U ), W ) ) }.
% 1.56/1.92 { ! alpha3( X, Y, Z, T, U, W ), hBOOL( hAPP( Y, bool, hAPP( X, fun( Y, bool
% 1.56/1.92 ), T, U ), W ) ) }.
% 1.56/1.92 { ! alpha3( X, Y, Z, T, U, W ), hBOOL( hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 ), member( product_prod( product_prod( X, Y ), product_prod( X, Y ) ) )
% 1.56/1.92 , hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), U ), W ) ), hAPP( Y, product_prod( X, Y ), hAPP( X
% 1.56/1.92 , fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol22( X, Y, Z,
% 1.56/1.92 T, U, W ) ), skol58( X, Y, Z, T, U, W ) ) ) ), Z ) ) }.
% 1.56/1.92 { ! alpha3( X, Y, Z, T, U, W ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun( Y,
% 1.56/1.92 bool ), T, skol22( X, Y, Z, T, U, W ) ), skol58( X, Y, Z, T, U, W ) ) ) }
% 1.56/1.92 .
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), U ), W
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), V0 ), V1 ) ) ), Z ) ), ! hBOOL( hAPP( Y, bool
% 1.56/1.92 , hAPP( X, fun( Y, bool ), T, U ), W ) ), hBOOL( hAPP( Y, bool, hAPP( X,
% 1.56/1.92 fun( Y, bool ), T, V0 ), V1 ) ), alpha3( X, Y, Z, T, U, W ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun
% 1.56/1.92 ( Y, bool ), V1, U ), W ) ), alpha4( X, Y, U, W, V0, skol23( X, Y, U, W,
% 1.56/1.92 V0, V1 ), skol59( X, Y, U, W, V0, V1 ), skol77( X, Y, U, W, V0, V1 ),
% 1.56/1.92 skol87( X, Y, U, W, V0, V1 ) ), hBOOL( hAPP( Y, bool, hAPP( X, fun( Y,
% 1.56/1.92 bool ), V1, Z ), T ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun
% 1.56/1.92 ( Y, bool ), V1, U ), W ) ), hBOOL( hAPP( Y, bool, hAPP( X, fun( Y, bool
% 1.56/1.92 ), V1, skol77( X, Y, U, W, V0, V1 ) ), skol87( X, Y, U, W, V0, V1 ) ) )
% 1.56/1.92 , hBOOL( hAPP( Y, bool, hAPP( X, fun( Y, bool ), V1, Z ), T ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun
% 1.56/1.92 ( Y, bool ), V1, U ), W ) ), ! hBOOL( hAPP( Y, bool, hAPP( X, fun( Y,
% 1.56/1.92 bool ), V1, skol23( X, Y, U, W, V0, V1 ) ), skol59( X, Y, U, W, V0, V1 )
% 1.56/1.92 ) ), hBOOL( hAPP( Y, bool, hAPP( X, fun( Y, bool ), V1, Z ), T ) ) }.
% 1.56/1.92 { ! alpha4( X, Y, Z, T, U, W, V0, V1, V2 ), hBOOL( hAPP( fun( product_prod
% 1.56/1.92 ( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 ), member( product_prod( product_prod( X, Y ), product_prod( X, Y ) ) )
% 1.56/1.92 , hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), W ), V0 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X
% 1.56/1.92 , fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), V1 ), V2 ) ) ), U
% 1.56/1.92 ) ) }.
% 1.56/1.92 { ! alpha4( X, Y, Z, T, U, W, V0, V1, V2 ), hBOOL( hAPP( fun( product_prod
% 1.56/1.92 ( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 ), member( product_prod( product_prod( X, Y ), product_prod( X, Y ) ) )
% 1.56/1.92 , hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), V1 ), V2 ) ), hAPP( Y, product_prod( X, Y ), hAPP(
% 1.56/1.92 X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T ) ) ),
% 1.56/1.92 hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X, Y ) ),
% 1.56/1.92 bool ), fun( product_prod( product_prod( X, Y ), product_prod( X, Y ) ),
% 1.56/1.92 bool ), transitive_rtrancl( product_prod( X, Y ) ), U ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), W ),
% 1.56/1.92 V0 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X,
% 1.56/1.92 Y ) ), product_Pair( X, Y ), V1 ), V2 ) ) ), U ) ), ! hBOOL( hAPP( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 , hAPP( product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun(
% 1.56/1.92 fun( product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ),
% 1.56/1.92 bool ), member( product_prod( product_prod( X, Y ), product_prod( X, Y )
% 1.56/1.92 ) ), hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), V1 ), V2 ) ), hAPP( Y, product_prod( X, Y ), hAPP(
% 1.56/1.92 X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T ) ) ),
% 1.56/1.92 hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X, Y ) ),
% 1.56/1.92 bool ), fun( product_prod( product_prod( X, Y ), product_prod( X, Y ) ),
% 1.56/1.92 bool ), transitive_rtrancl( product_prod( X, Y ) ), U ) ) ), alpha4( X, Y
% 1.56/1.92 , Z, T, U, W, V0, V1, V2 ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), hAPP( Y, product_prod( X, Y ), hAPP(
% 1.56/1.92 X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T ) = hAPP
% 1.56/1.92 ( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), U ), W ), hBOOL( hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 ), member( product_prod( product_prod( X, Y ), product_prod( X, Y ) ) )
% 1.56/1.92 , hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), Z ), T ) ), hAPP( Y, product_prod( X, Y ), hAPP( X
% 1.56/1.92 , fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), skol24( X, Y, Z,
% 1.56/1.92 T, U, W, V0 ) ), skol60( X, Y, Z, T, U, W, V0 ) ) ) ), V0 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( X, Y ), product_prod( X,
% 1.56/1.92 Y ) ), bool ), bool, hAPP( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), fun( fun( product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), bool ), bool ), member( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), hAPP( product_prod( X, Y
% 1.56/1.92 ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ), hAPP(
% 1.56/1.92 product_prod( X, Y ), fun( product_prod( X, Y ), product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ) ), product_Pair(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y, product_prod( X, Y
% 1.56/1.92 ), hAPP( X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T
% 1.56/1.92 ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y
% 1.56/1.92 ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), transitive_rtrancl
% 1.56/1.92 ( product_prod( X, Y ) ), V0 ) ) ), hAPP( Y, product_prod( X, Y ), hAPP(
% 1.56/1.92 X, fun( Y, product_prod( X, Y ) ), product_Pair( X, Y ), Z ), T ) = hAPP
% 1.56/1.92 ( Y, product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), U ), W ), hBOOL( hAPP( fun( product_prod(
% 1.56/1.92 product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), fun( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), bool
% 1.56/1.92 ), member( product_prod( product_prod( X, Y ), product_prod( X, Y ) ) )
% 1.56/1.92 , hAPP( product_prod( X, Y ), product_prod( product_prod( X, Y ),
% 1.56/1.92 product_prod( X, Y ) ), hAPP( product_prod( X, Y ), fun( product_prod( X
% 1.56/1.92 , Y ), product_prod( product_prod( X, Y ), product_prod( X, Y ) ) ),
% 1.56/1.92 product_Pair( product_prod( X, Y ), product_prod( X, Y ) ), hAPP( Y,
% 1.56/1.92 product_prod( X, Y ), hAPP( X, fun( Y, product_prod( X, Y ) ),
% 1.56/1.92 product_Pair( X, Y ), skol24( X, Y, Z, T, U, W, V0 ) ), skol60( X, Y, Z,
% 1.56/1.92 T, U, W, V0 ) ) ), hAPP( Y, product_prod( X, Y ), hAPP( X, fun( Y,
% 1.56/1.92 product_prod( X, Y ) ), product_Pair( X, Y ), U ), W ) ) ), hAPP( fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ), fun(
% 1.56/1.92 product_prod( product_prod( X, Y ), product_prod( X, Y ) ), bool ),
% 1.56/1.92 transitive_rtrancl( product_prod( X, Y ) ), V0 ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ti( X, Y ) = ti( X, Z ), hBOOL( hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X ), fun
% 1.56/1.92 ( fun( product_prod( X, X ), bool ), bool ), member( product_prod( X, X )
% 1.56/1.92 ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X )
% 1.56/1.92 ), product_Pair( X, X ), Y ), skol25( X, Y, U, T ) ) ), hAPP( fun(
% 1.56/1.92 product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ti( X, Y ) = ti( X, Z ), hBOOL( hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X ), fun
% 1.56/1.92 ( fun( product_prod( X, X ), bool ), bool ), member( product_prod( X, X )
% 1.56/1.92 ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X )
% 1.56/1.92 ), product_Pair( X, X ), skol25( X, Y, Z, T ) ), Z ) ), T ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ti( X, Y ) = ti( X, Z ), hBOOL( hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X ), fun
% 1.56/1.92 ( fun( product_prod( X, X ), bool ), bool ), member( product_prod( X, X )
% 1.56/1.92 ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X )
% 1.56/1.92 ), product_Pair( X, X ), Y ), skol26( X, Y, U, T ) ) ), T ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ti( X, Y ) = ti( X, Z ), hBOOL( hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X ), fun
% 1.56/1.92 ( fun( product_prod( X, X ), bool ), bool ), member( product_prod( X, X )
% 1.56/1.92 ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X, product_prod( X, X )
% 1.56/1.92 ), product_Pair( X, X ), skol26( X, Y, Z, T ) ), Z ) ), hAPP( fun(
% 1.56/1.92 product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( X, bool, U, Z ) ), hBOOL
% 1.56/1.92 ( hAPP( X, bool, U, skol61( X, W, V0, U ) ) ), hBOOL( hAPP( X, bool, U, Y
% 1.56/1.92 ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( X, bool, U, Z ) ),
% 1.56/1.92 alpha5( X, Z, T, skol27( X, Z, T, U ), skol61( X, Z, T, U ) ), hBOOL(
% 1.56/1.92 hAPP( X, bool, U, Y ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( X, bool, U, Z ) ), !
% 1.56/1.92 hBOOL( hAPP( X, bool, U, skol27( X, Z, T, U ) ) ), hBOOL( hAPP( X, bool,
% 1.56/1.92 U, Y ) ) }.
% 1.56/1.92 { ! alpha5( X, Y, Z, T, U ), hBOOL( hAPP( fun( product_prod( X, X ), bool )
% 1.56/1.92 , bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X, X ), bool
% 1.56/1.92 ), bool ), member( product_prod( X, X ) ), hAPP( X, product_prod( X, X )
% 1.56/1.92 , hAPP( X, fun( X, product_prod( X, X ) ), product_Pair( X, X ), T ), U )
% 1.56/1.92 ), Z ) ) }.
% 1.56/1.92 { ! alpha5( X, Y, Z, T, U ), hBOOL( hAPP( fun( product_prod( X, X ), bool )
% 1.56/1.92 , bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X, X ), bool
% 1.56/1.92 ), bool ), member( product_prod( X, X ) ), hAPP( X, product_prod( X, X )
% 1.56/1.92 , hAPP( X, fun( X, product_prod( X, X ) ), product_Pair( X, X ), U ), Y )
% 1.56/1.92 ), hAPP( fun( product_prod( X, X ), bool ), fun( product_prod( X, X ),
% 1.56/1.92 bool ), transitive_rtrancl( X ), Z ) ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), T ), U ) ), Z ) ),
% 1.56/1.92 ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), U ), Y ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), Z ) ) ), alpha5( X, Y, Z, T, U ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( X, bool, U, Y ) ), hBOOL
% 1.56/1.92 ( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP( product_prod( X, X
% 1.56/1.92 ), fun( fun( product_prod( X, X ), bool ), bool ), member( product_prod
% 1.56/1.92 ( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X, fun( X, product_prod
% 1.56/1.92 ( X, X ) ), product_Pair( X, X ), Y ), skol28( X, Y, T, W ) ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), hBOOL( hAPP( X, bool, U, Z ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), Y ), Z ) ), hAPP(
% 1.56/1.92 fun( product_prod( X, X ), bool ), fun( product_prod( X, X ), bool ),
% 1.56/1.92 transitive_rtrancl( X ), T ) ) ), ! hBOOL( hAPP( X, bool, U, Y ) ),
% 1.56/1.92 alpha6( X, T, U, skol28( X, Y, T, U ) ), hBOOL( hAPP( X, bool, U, Z ) ) }
% 1.56/1.92 .
% 1.56/1.92 { ! alpha6( X, Y, Z, T ), ! hBOOL( hAPP( X, bool, Z, skol29( X, U, Z, W ) )
% 1.56/1.92 ) }.
% 1.56/1.92 { ! alpha6( X, Y, Z, T ), hBOOL( hAPP( X, bool, Z, T ) ) }.
% 1.56/1.92 { ! alpha6( X, Y, Z, T ), hBOOL( hAPP( fun( product_prod( X, X ), bool ),
% 1.56/1.92 bool, hAPP( product_prod( X, X ), fun( fun( product_prod( X, X ), bool )
% 1.56/1.92 , bool ), member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ),
% 1.56/1.92 hAPP( X, fun( X, product_prod( X, X ) ), product_Pair( X, X ), T ),
% 1.56/1.92 skol29( X, Y, Z, T ) ) ), Y ) ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( X, X ), bool ), bool, hAPP(
% 1.56/1.92 product_prod( X, X ), fun( fun( product_prod( X, X ), bool ), bool ),
% 1.56/1.92 member( product_prod( X, X ) ), hAPP( X, product_prod( X, X ), hAPP( X,
% 1.56/1.92 fun( X, product_prod( X, X ) ), product_Pair( X, X ), T ), U ) ), Y ) ),
% 1.56/1.92 ! hBOOL( hAPP( X, bool, Z, T ) ), hBOOL( hAPP( X, bool, Z, U ) ), alpha6
% 1.56/1.92 ( X, Y, Z, T ) }.
% 1.56/1.92 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.92 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), Y ), Z )
% 1.56/1.92 ) ), hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), V0 ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), T ), U )
% 1.56/1.92 ) ) ), hAPP( list( product_prod( list( char ), product_prod( list( char
% 1.56/1.92 ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), red, W ) ) ), ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char
% 1.56/1.92 ) ), fun( ty, bool ), hAPP( fun( list( char ), option( ty ) ), fun( exp
% 1.56/1.92 ( list( char ) ), fun( ty, bool ) ), hAPP( fun( nat, option( product_prod
% 1.56/1.92 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun( exp( list(
% 1.56/1.92 char ) ), fun( ty, bool ) ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.92 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.92 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.92 product_prod( ty, product_prod( list( list( char ) ), exp( list( char ) )
% 1.56/1.92 ) ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.92 , bool ) ) ) ), wTrt, W ), Y ), V1 ), X ), V2 ) ), ! hBOOL( hAPP( fun(
% 1.56/1.92 list( char ), option( ty ) ), bool, hAPP( fun( list( char ), option( val
% 1.56/1.92 ) ), fun( fun( list( char ), option( ty ) ), bool ), hAPP( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( val )
% 1.56/1.92 ), fun( fun( list( char ), option( ty ) ), bool ) ), hAPP( list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.92 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.92 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.92 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ), fun
% 1.56/1.92 ( fun( list( char ), option( ty ) ), bool ) ) ), lconf( product_prod(
% 1.56/1.92 list( list( char ) ), exp( list( char ) ) ) ), W ), Y ), Z ), V1 ) ),
% 1.56/1.92 hBOOL( hAPP( fun( list( char ), option( ty ) ), bool, hAPP( fun( list(
% 1.56/1.92 char ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ),
% 1.56/1.92 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ),
% 1.56/1.92 hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.92 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.92 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.92 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.92 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.92 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.92 ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ) ),
% 1.56/1.92 lconf( product_prod( list( list( char ) ), exp( list( char ) ) ) ), W ),
% 1.56/1.92 T ), U ), V1 ) ) }.
% 1.56/1.92 { ! hAPP( list( list( char ) ), nat, size_size( list( list( char ) ) ), X )
% 1.56/1.92 = hAPP( list( ty ), nat, size_size( list( ty ) ), Y ), ! hAPP( list( val
% 1.56/1.92 ), nat, size_size( list( val ) ), Z ) = hAPP( list( ty ), nat, size_size
% 1.56/1.92 ( list( ty ) ), Y ), ! hBOOL( hAPP( list( list( char ) ), bool, distinct
% 1.56/1.92 ( list( char ) ), X ) ), ! hBOOL( hAPP( fun( product_prod( product_prod(
% 1.56/1.92 exp( list( char ) ), product_prod( fun( nat, option( product_prod( list(
% 1.56/1.92 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.92 ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.92 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.92 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.92 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.92 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.92 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.92 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.92 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.92 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option
% 1.56/1.92 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), U ),
% 1.56/1.92 hAPP( list( val ), fun( list( char ), option( val ) ), hAPP( list( list(
% 1.56/1.92 char ) ), fun( list( val ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.92 fun( list( char ), option( val ) ), fun( list( list( char ) ), fun( list
% 1.56/1.92 ( val ), fun( list( char ), option( val ) ) ) ), map_upds( list( char ),
% 1.56/1.92 val ), W ), X ), Z ) ) ) ), hAPP( product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.92 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.92 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.92 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.92 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.92 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.92 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ) ), V0 ), hAPP( fun( list( char ),
% 1.56/1.92 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.92 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.92 ), fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), V1 ), V2
% 1.56/1.92 ) ) ) ), hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), fun( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.92 ), transitive_rtrancl( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.92 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.92 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.92 ( val ) ) ) ) ), hAPP( list( product_prod( list( char ), product_prod(
% 1.56/1.92 list( char ), product_prod( list( product_prod( list( char ), ty ) ),
% 1.56/1.92 list( product_prod( list( char ), product_prod( list( ty ), product_prod
% 1.56/1.92 ( ty, product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) )
% 1.56/1.92 ) ) ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), bool ), red, V3 ) ) ) ), ! hBOOL(
% 1.56/1.92 hAPP( exp( list( char ) ), bool, final( list( char ) ), V0 ) ), ! V4 =
% 1.56/1.92 hAPP( fun( list( char ), bool ), fun( list( char ), option( val ) ), hAPP
% 1.56/1.92 ( fun( list( char ), option( val ) ), fun( fun( list( char ), bool ), fun
% 1.56/1.92 ( list( char ), option( val ) ) ), hAPP( fun( list( char ), option( val )
% 1.56/1.92 ), fun( fun( list( char ), option( val ) ), fun( fun( list( char ), bool
% 1.56/1.92 ), fun( list( char ), option( val ) ) ) ), override_on( list( char ),
% 1.56/1.92 option( val ) ), V2 ), W ), hAPP( list( list( char ) ), fun( list( char )
% 1.56/1.92 , bool ), set( list( char ) ), X ) ), hBOOL( hAPP( fun( product_prod(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.92 ), bool, hAPP( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ) ) ), fun( fun( product_prod( product_prod
% 1.56/1.92 ( exp( list( char ) ), product_prod( fun( nat, option( product_prod( list
% 1.56/1.92 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.92 ) ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list
% 1.56/1.92 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.92 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.92 fun( list( char ), option( val ) ) ) ) ), bool ), bool ), member(
% 1.56/1.92 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.92 hAPP( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.92 ( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), fun(
% 1.56/1.92 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.92 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.92 product_Pair( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.92 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.92 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.92 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.92 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.92 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.92 ( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.92 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.92 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.92 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( product_prod( list( list( char )
% 1.56/1.93 ), product_prod( list( ty ), product_prod( list( val ), exp( list( char
% 1.56/1.93 ) ) ) ) ), exp( list( char ) ), blocks, hAPP( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ), hAPP( list( list( char ) ), fun( product_prod(
% 1.56/1.93 list( ty ), product_prod( list( val ), exp( list( char ) ) ) ),
% 1.56/1.93 product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ) ) ), product_Pair(
% 1.56/1.93 list( list( char ) ), product_prod( list( ty ), product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ) ) ), X ), hAPP( product_prod( list( val ), exp(
% 1.56/1.93 list( char ) ) ), product_prod( list( ty ), product_prod( list( val ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( list( ty ), fun( product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ), product_prod( list( ty ), product_prod( list(
% 1.56/1.93 val ), exp( list( char ) ) ) ) ), product_Pair( list( ty ), product_prod
% 1.56/1.93 ( list( val ), exp( list( char ) ) ) ), Y ), hAPP( exp( list( char ) ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ), hAPP( list( val ), fun
% 1.56/1.93 ( exp( list( char ) ), product_prod( list( val ), exp( list( char ) ) ) )
% 1.56/1.93 , product_Pair( list( val ), exp( list( char ) ) ), Z ), T ) ) ) ) ),
% 1.56/1.93 hAPP( fun( list( char ), option( val ) ), product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_Pair( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 U ), W ) ) ), hAPP( product_prod( fun( nat, option( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), V0 ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), V1 ), V4
% 1.56/1.93 ) ) ) ), hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), transitive_rtrancl( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ) ), hAPP( list( product_prod( list( char ), product_prod(
% 1.56/1.93 list( char ), product_prod( list( product_prod( list( char ), ty ) ),
% 1.56/1.93 list( product_prod( list( char ), product_prod( list( ty ), product_prod
% 1.56/1.93 ( ty, product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) )
% 1.56/1.93 ) ) ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, V3 ) ) ) ) }.
% 1.56/1.93 { ! hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun( list( X ), list( Y
% 1.56/1.93 ) ), map( X, Y ), Z ), T ) = hAPP( list( X ), list( Y ), hAPP( fun( X, Y
% 1.56/1.93 ), fun( list( X ), list( Y ) ), map( X, Y ), U ), T ), ! hBOOL( hAPP(
% 1.56/1.93 fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ), member( X ),
% 1.56/1.93 W ), hAPP( list( X ), fun( X, bool ), set( X ), T ) ) ), hAPP( X, Y, Z, W
% 1.56/1.93 ) = hAPP( X, Y, U, W ) }.
% 1.56/1.93 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 1.56/1.93 member( X ), skol30( X, W, V0, T, V1 ) ), hAPP( list( X ), fun( X, bool )
% 1.56/1.93 , set( X ), T ) ) ), hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun(
% 1.56/1.93 list( X ), list( Y ) ), map( X, Y ), Z ), T ) = hAPP( list( X ), list( Y
% 1.56/1.93 ), hAPP( fun( X, Y ), fun( list( X ), list( Y ) ), map( X, Y ), U ), T )
% 1.56/1.93 }.
% 1.56/1.93 { ! hAPP( X, Y, Z, skol30( X, Y, Z, T, U ) ) = hAPP( X, Y, U, skol30( X, Y
% 1.56/1.93 , Z, T, U ) ), hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun( list(
% 1.56/1.93 X ), list( Y ) ), map( X, Y ), Z ), T ) = hAPP( list( X ), list( Y ),
% 1.56/1.93 hAPP( fun( X, Y ), fun( list( X ), list( Y ) ), map( X, Y ), U ), T ) }.
% 1.56/1.93 { ! hAPP( X, Y, Z, skol31( X, Y, Z, T ) ) = hAPP( X, Y, T, skol31( X, Y, Z
% 1.56/1.93 , T ) ), ti( fun( X, Y ), Z ) = ti( fun( X, Y ), T ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool )
% 1.56/1.93 , member( X ), Y ), Z ) ), hBOOL( hAPP( X, bool, Z, Y ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( X, bool, Z, Y ) ), hBOOL( hAPP( fun( X, bool ), bool, hAPP
% 1.56/1.93 ( X, fun( fun( X, bool ), bool ), member( X ), Y ), Z ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( list( char ), option( ty ) ), bool, hAPP( fun( list(
% 1.56/1.93 char ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ),
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ),
% 1.56/1.93 hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.93 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( list( char ), option( val ) ), fun( fun( list( char ), option( ty
% 1.56/1.93 ) ), bool ) ) ), lconf( X ), Y ), Z ), T ), U ) ), ! hBOOL( hAPP( fun(
% 1.56/1.93 nat, option( product_prod( list( char ), fun( product_prod( list( char )
% 1.56/1.93 , list( char ) ), option( val ) ) ) ) ), bool, hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( nat, option( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ) ) ), bool ), hext, Z ), W ) ), hBOOL( hAPP( fun( list( char ), option
% 1.56/1.93 ( ty ) ), bool, hAPP( fun( list( char ), option( val ) ), fun( fun( list
% 1.56/1.93 ( char ), option( ty ) ), bool ), hAPP( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), fun( fun( list(
% 1.56/1.93 char ), option( ty ) ), bool ) ), hAPP( list( product_prod( list( char )
% 1.56/1.93 , product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.93 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.93 ), product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ), fun(
% 1.56/1.93 fun( list( char ), option( ty ) ), bool ) ) ), lconf( X ), Y ), W ), T )
% 1.56/1.93 , U ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( list( char ), option( ty ) ), bool, hAPP( fun( list(
% 1.56/1.93 char ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ),
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ),
% 1.56/1.93 hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.93 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( list( char ), option( val ) ), fun( fun( list( char ), option( ty
% 1.56/1.93 ) ), bool ) ) ), lconf( X ), Y ), Z ), T ), U ) ), ! hAPP( list( char )
% 1.56/1.93 , option( val ), T, W ) = hAPP( val, option( val ), some( val ), V0 ),
% 1.56/1.93 alpha1( X, Y, Z, U, W, V0 ) }.
% 1.56/1.93 { hAPP( list( char ), option( val ), T, skol32( X, Y, Z, T, U ) ) = hAPP(
% 1.56/1.93 val, option( val ), some( val ), skol62( X, Y, Z, T, U ) ), hBOOL( hAPP(
% 1.56/1.93 fun( list( char ), option( ty ) ), bool, hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), fun( fun( list( char ), option( ty ) ), bool ), hAPP( fun( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ), option(
% 1.56/1.93 val ) ), fun( fun( list( char ), option( ty ) ), bool ) ), hAPP( list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.93 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( ty ), product_prod( ty, X ) ) ) ) ) ) ) ), fun(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ) ),
% 1.56/1.93 lconf( X ), Y ), Z ), T ), U ) ) }.
% 1.56/1.93 { ! alpha1( X, Y, Z, U, skol32( X, Y, Z, T, U ), skol62( X, Y, Z, T, U ) )
% 1.56/1.93 , hBOOL( hAPP( fun( list( char ), option( ty ) ), bool, hAPP( fun( list(
% 1.56/1.93 char ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ),
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( val ) ), fun( fun( list( char ), option( ty ) ), bool ) ),
% 1.56/1.93 hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.93 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( list( char ), option( val ) ), fun( fun( list( char ), option( ty
% 1.56/1.93 ) ), bool ) ) ), lconf( X ), Y ), Z ), T ), U ) ) }.
% 1.56/1.93 { ! alpha1( X, Y, Z, T, U, W ), hAPP( list( char ), option( ty ), T, U ) =
% 1.56/1.93 hAPP( ty, option( ty ), some( ty ), skol33( V0, V1, V2, T, U, V3 ) ) }.
% 1.56/1.93 { ! alpha1( X, Y, Z, T, U, W ), hBOOL( hAPP( ty, bool, hAPP( val, fun( ty,
% 1.56/1.93 bool ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 val, fun( ty, bool ) ), hAPP( list( product_prod( list( char ),
% 1.56/1.93 product_prod( list( char ), product_prod( list( product_prod( list( char
% 1.56/1.93 ), ty ) ), list( product_prod( list( char ), product_prod( list( ty ),
% 1.56/1.93 product_prod( ty, X ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod
% 1.56/1.93 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), W ),
% 1.56/1.93 skol33( X, Y, Z, T, U, W ) ) ) }.
% 1.56/1.93 { ! hAPP( list( char ), option( ty ), T, U ) = hAPP( ty, option( ty ), some
% 1.56/1.93 ( ty ), V0 ), ! hBOOL( hAPP( ty, bool, hAPP( val, fun( ty, bool ), hAPP(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( val, fun( ty, bool )
% 1.56/1.93 ), hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty, X
% 1.56/1.93 ) ) ) ) ) ) ) ), fun( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( val, fun( ty, bool ) ) ), conf( X ), Y ), Z ), W ), V0 ) ), alpha1( X,
% 1.56/1.93 Y, Z, T, U, W ) }.
% 1.56/1.93 { ! hAPP( list( list( char ) ), nat, size_size( list( list( char ) ) ), X )
% 1.56/1.93 = hAPP( list( ty ), nat, size_size( list( ty ) ), Y ), ! hAPP( list( val
% 1.56/1.93 ), nat, size_size( list( val ) ), Z ) = hAPP( list( ty ), nat, size_size
% 1.56/1.93 ( list( ty ) ), Y ), ! hBOOL( hAPP( list( list( char ) ), bool, distinct
% 1.56/1.93 ( list( char ) ), X ) ), ! hBOOL( hAPP( fun( product_prod( product_prod(
% 1.56/1.93 exp( list( char ) ), product_prod( fun( nat, option( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), U ),
% 1.56/1.93 hAPP( list( val ), fun( list( char ), option( val ) ), hAPP( list( list(
% 1.56/1.93 char ) ), fun( list( val ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.93 fun( list( char ), option( val ) ), fun( list( list( char ) ), fun( list
% 1.56/1.93 ( val ), fun( list( char ), option( val ) ) ) ), map_upds( list( char ),
% 1.56/1.93 val ), W ), X ), Z ) ) ) ), hAPP( product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), V0 ), hAPP( fun( list( char ),
% 1.56/1.93 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), V1 ), V2
% 1.56/1.93 ) ) ) ), hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), transitive_rtrancl( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ) ), hAPP( list( product_prod( list( char ), product_prod(
% 1.56/1.93 list( char ), product_prod( list( product_prod( list( char ), ty ) ),
% 1.56/1.93 list( product_prod( list( char ), product_prod( list( ty ), product_prod
% 1.56/1.93 ( ty, product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) )
% 1.56/1.93 ) ) ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, V3 ) ) ) ), hBOOL( hAPP
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool, hAPP( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), fun( fun( product_prod( product_prod
% 1.56/1.93 ( exp( list( char ) ), product_prod( fun( nat, option( product_prod( list
% 1.56/1.93 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.93 ) ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ) ), bool ), bool ), member(
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 hAPP( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), fun(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 product_Pair( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( product_prod( list( list( char )
% 1.56/1.93 ), product_prod( list( ty ), product_prod( list( val ), exp( list( char
% 1.56/1.93 ) ) ) ) ), exp( list( char ) ), blocks, hAPP( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ), hAPP( list( list( char ) ), fun( product_prod(
% 1.56/1.93 list( ty ), product_prod( list( val ), exp( list( char ) ) ) ),
% 1.56/1.93 product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ) ) ), product_Pair(
% 1.56/1.93 list( list( char ) ), product_prod( list( ty ), product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ) ) ), X ), hAPP( product_prod( list( val ), exp(
% 1.56/1.93 list( char ) ) ), product_prod( list( ty ), product_prod( list( val ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( list( ty ), fun( product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ), product_prod( list( ty ), product_prod( list(
% 1.56/1.93 val ), exp( list( char ) ) ) ) ), product_Pair( list( ty ), product_prod
% 1.56/1.93 ( list( val ), exp( list( char ) ) ) ), Y ), hAPP( exp( list( char ) ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ), hAPP( list( val ), fun
% 1.56/1.93 ( exp( list( char ) ), product_prod( list( val ), exp( list( char ) ) ) )
% 1.56/1.93 , product_Pair( list( val ), exp( list( char ) ) ), Z ), T ) ) ) ) ),
% 1.56/1.93 hAPP( fun( list( char ), option( val ) ), product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), hAPP(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_Pair( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 U ), W ) ) ), hAPP( product_prod( fun( nat, option( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( product_prod( list( list( char )
% 1.56/1.93 ), product_prod( list( ty ), product_prod( list( val ), exp( list( char
% 1.56/1.93 ) ) ) ) ), exp( list( char ) ), blocks, hAPP( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ), hAPP( list( list( char ) ), fun( product_prod(
% 1.56/1.93 list( ty ), product_prod( list( val ), exp( list( char ) ) ) ),
% 1.56/1.93 product_prod( list( list( char ) ), product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ) ) ), product_Pair(
% 1.56/1.93 list( list( char ) ), product_prod( list( ty ), product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ) ) ), X ), hAPP( product_prod( list( val ), exp(
% 1.56/1.93 list( char ) ) ), product_prod( list( ty ), product_prod( list( val ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( list( ty ), fun( product_prod( list( val )
% 1.56/1.93 , exp( list( char ) ) ), product_prod( list( ty ), product_prod( list(
% 1.56/1.93 val ), exp( list( char ) ) ) ) ), product_Pair( list( ty ), product_prod
% 1.56/1.93 ( list( val ), exp( list( char ) ) ) ), Y ), hAPP( exp( list( char ) ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ), hAPP( list( val ), fun
% 1.56/1.93 ( exp( list( char ) ), product_prod( list( val ), exp( list( char ) ) ) )
% 1.56/1.93 , product_Pair( list( val ), exp( list( char ) ) ), hAPP( list( list(
% 1.56/1.93 char ) ), list( val ), hAPP( fun( list( char ), val ), fun( list( list(
% 1.56/1.93 char ) ), list( val ) ), map( list( char ), val ), hAPP( fun( list( char
% 1.56/1.93 ), option( val ) ), fun( list( char ), val ), hAPP( fun( option( val ),
% 1.56/1.93 val ), fun( fun( list( char ), option( val ) ), fun( list( char ), val )
% 1.56/1.93 ), comp( option( val ), val, list( char ) ), the( val ) ), V2 ) ), X ) )
% 1.56/1.93 , V0 ) ) ) ) ), hAPP( fun( list( char ), option( val ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( list( char ), option( val ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_Pair( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), V1 ), hAPP( fun( list( char ), bool ),
% 1.56/1.93 fun( list( char ), option( val ) ), hAPP( fun( list( char ), option( val
% 1.56/1.93 ) ), fun( fun( list( char ), bool ), fun( list( char ), option( val ) )
% 1.56/1.93 ), hAPP( fun( list( char ), option( val ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( fun( list( char ), bool ), fun( list( char ),
% 1.56/1.93 option( val ) ) ) ), override_on( list( char ), option( val ) ), V2 ), W
% 1.56/1.93 ), hAPP( list( list( char ) ), fun( list( char ), bool ), set( list(
% 1.56/1.93 char ) ), X ) ) ) ) ) ), hAPP( fun( product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), transitive_rtrancl( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ) ), hAPP( list( product_prod( list( char ), product_prod(
% 1.56/1.93 list( char ), product_prod( list( product_prod( list( char ), ty ) ),
% 1.56/1.93 list( product_prod( list( char ), product_prod( list( ty ), product_prod
% 1.56/1.93 ( ty, product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) )
% 1.56/1.93 ) ) ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, V3 ) ) ) ) }.
% 1.56/1.93 { hAPP( fun( list( X ), list( Y ) ), fun( list( X ), list( Z ) ), hAPP( fun
% 1.56/1.93 ( list( Y ), list( Z ) ), fun( fun( list( X ), list( Y ) ), fun( list( X
% 1.56/1.93 ), list( Z ) ) ), comp( list( Y ), list( Z ), list( X ) ), hAPP( fun( Y
% 1.56/1.93 , Z ), fun( list( Y ), list( Z ) ), map( Y, Z ), T ) ), hAPP( fun( X, Y )
% 1.56/1.93 , fun( list( X ), list( Y ) ), map( X, Y ), U ) ) = hAPP( fun( X, Z ),
% 1.56/1.93 fun( list( X ), list( Z ) ), map( X, Z ), hAPP( fun( X, Y ), fun( X, Z )
% 1.56/1.93 , hAPP( fun( Y, Z ), fun( fun( X, Y ), fun( X, Z ) ), comp( Y, Z, X ), T
% 1.56/1.93 ), U ) ) }.
% 1.56/1.93 { hAPP( fun( list( X ), list( Y ) ), fun( list( X ), list( Z ) ), hAPP( fun
% 1.56/1.93 ( list( Y ), list( Z ) ), fun( fun( list( X ), list( Y ) ), fun( list( X
% 1.56/1.93 ), list( Z ) ) ), comp( list( Y ), list( Z ), list( X ) ), hAPP( fun( Y
% 1.56/1.93 , Z ), fun( list( Y ), list( Z ) ), map( Y, Z ), T ) ), hAPP( fun( X, Y )
% 1.56/1.93 , fun( list( X ), list( Y ) ), map( X, Y ), U ) ) = hAPP( fun( X, Z ),
% 1.56/1.93 fun( list( X ), list( Z ) ), map( X, Z ), hAPP( fun( X, Y ), fun( X, Z )
% 1.56/1.93 , hAPP( fun( Y, Z ), fun( fun( X, Y ), fun( X, Z ) ), comp( Y, Z, X ), T
% 1.56/1.93 ), U ) ) }.
% 1.56/1.93 { hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun( list( X ), list( Y )
% 1.56/1.93 ), map( X, Y ), T ), hAPP( list( Z ), list( X ), hAPP( fun( Z, X ), fun
% 1.56/1.93 ( list( Z ), list( X ) ), map( Z, X ), U ), W ) ) = hAPP( list( Z ), list
% 1.56/1.93 ( Y ), hAPP( fun( Z, Y ), fun( list( Z ), list( Y ) ), map( Z, Y ), hAPP
% 1.56/1.93 ( fun( Z, X ), fun( Z, Y ), hAPP( fun( X, Y ), fun( fun( Z, X ), fun( Z,
% 1.56/1.93 Y ) ), comp( X, Y, Z ), T ), U ) ), W ) }.
% 1.56/1.93 { hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun( list( X ), list( Y )
% 1.56/1.93 ), map( X, Y ), T ), hAPP( list( Z ), list( X ), hAPP( fun( Z, X ), fun
% 1.56/1.93 ( list( Z ), list( X ) ), map( Z, X ), U ), W ) ) = hAPP( list( Z ), list
% 1.56/1.93 ( Y ), hAPP( fun( Z, Y ), fun( list( Z ), list( Y ) ), map( Z, Y ), hAPP
% 1.56/1.93 ( fun( Z, X ), fun( Z, Y ), hAPP( fun( X, Y ), fun( fun( Z, X ), fun( Z,
% 1.56/1.93 Y ) ), comp( X, Y, Z ), T ), U ) ), W ) }.
% 1.56/1.93 { hAPP( option( X ), X, the( X ), hAPP( X, option( X ), some( X ), Y ) ) =
% 1.56/1.93 ti( X, Y ) }.
% 1.56/1.93 { ! Z = hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun( list( X ), list
% 1.56/1.93 ( Y ) ), map( X, Y ), T ), U ), ! hBOOL( hAPP( fun( Y, bool ), bool, hAPP
% 1.56/1.93 ( Y, fun( fun( Y, bool ), bool ), member( Y ), W ), hAPP( list( Y ), fun
% 1.56/1.93 ( Y, bool ), set( Y ), Z ) ) ), ti( Y, W ) = hAPP( X, Y, T, skol34( X, Y
% 1.56/1.93 , T, W ) ) }.
% 1.56/1.93 { hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool ),
% 1.56/1.93 member( Y ), skol63( U, Y, Z, W ) ), hAPP( list( Y ), fun( Y, bool ), set
% 1.56/1.93 ( Y ), Z ) ) ), Z = hAPP( list( X ), list( Y ), hAPP( fun( X, Y ), fun(
% 1.56/1.93 list( X ), list( Y ) ), map( X, Y ), T ), skol78( X, Y, Z, T ) ) }.
% 1.56/1.93 { ! ti( Y, skol63( X, Y, Z, T ) ) = hAPP( X, Y, T, U ), Z = hAPP( list( X )
% 1.56/1.93 , list( Y ), hAPP( fun( X, Y ), fun( list( X ), list( Y ) ), map( X, Y )
% 1.56/1.93 , T ), skol78( X, Y, Z, T ) ) }.
% 1.56/1.93 { hBOOL( hAPP( fun( Y, bool ), bool, hAPP( Y, fun( fun( Y, bool ), bool ),
% 1.56/1.93 member( Y ), skol35( W, Y, V0, V1, U ) ), hAPP( list( Y ), fun( Y, bool )
% 1.56/1.93 , set( Y ), U ) ) ), hAPP( list( Y ), list( X ), hAPP( fun( Y, X ), fun(
% 1.56/1.93 list( Y ), list( X ) ), map( Y, X ), Z ), U ) = hAPP( list( Y ), list( X
% 1.56/1.93 ), hAPP( fun( Y, X ), fun( list( Y ), list( X ) ), map( Y, X ), T ), U )
% 1.56/1.93 }.
% 1.56/1.93 { ! hAPP( Y, X, Z, skol35( X, Y, Z, T, U ) ) = hAPP( Y, X, T, skol35( X, Y
% 1.56/1.93 , Z, T, U ) ), hAPP( list( Y ), list( X ), hAPP( fun( Y, X ), fun( list(
% 1.56/1.93 Y ), list( X ) ), map( Y, X ), Z ), U ) = hAPP( list( Y ), list( X ),
% 1.56/1.93 hAPP( fun( Y, X ), fun( list( Y ), list( X ) ), map( Y, X ), T ), U ) }.
% 1.56/1.93 { ! X = Y, hBOOL( hAPP( fun( T, bool ), bool, hAPP( T, fun( fun( T, bool )
% 1.56/1.93 , bool ), member( T ), skol36( Y, V0, T, V1, V2 ) ), hAPP( list( T ), fun
% 1.56/1.93 ( T, bool ), set( T ), Y ) ) ), hAPP( list( T ), list( Z ), hAPP( fun( T
% 1.56/1.93 , Z ), fun( list( T ), list( Z ) ), map( T, Z ), U ), X ) = hAPP( list( T
% 1.56/1.93 ), list( Z ), hAPP( fun( T, Z ), fun( list( T ), list( Z ) ), map( T, Z
% 1.56/1.93 ), W ), Y ) }.
% 1.56/1.93 { ! X = Y, ! hAPP( T, Z, U, skol36( Y, Z, T, U, W ) ) = hAPP( T, Z, W,
% 1.56/1.93 skol36( Y, Z, T, U, W ) ), hAPP( list( T ), list( Z ), hAPP( fun( T, Z )
% 1.56/1.93 , fun( list( T ), list( Z ) ), map( T, Z ), U ), X ) = hAPP( list( T ),
% 1.56/1.93 list( Z ), hAPP( fun( T, Z ), fun( list( T ), list( Z ) ), map( T, Z ), W
% 1.56/1.93 ), Y ) }.
% 1.56/1.93 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 1.56/1.93 member( X ), skol37( X, T, Z ) ), hAPP( list( X ), fun( X, bool ), set( X
% 1.56/1.93 ), Z ) ) ), hAPP( list( X ), list( X ), hAPP( fun( X, X ), fun( list( X
% 1.56/1.93 ), list( X ) ), map( X, X ), Y ), Z ) = Z }.
% 1.56/1.93 { ! hAPP( X, X, Y, skol37( X, Y, Z ) ) = ti( X, skol37( X, Y, Z ) ), hAPP(
% 1.56/1.93 list( X ), list( X ), hAPP( fun( X, X ), fun( list( X ), list( X ) ), map
% 1.56/1.93 ( X, X ), Y ), Z ) = Z }.
% 1.56/1.93 { hBOOL( hAPP( fun( X, bool ), bool, hAPP( X, fun( fun( X, bool ), bool ),
% 1.56/1.93 member( X ), Y ), hAPP( list( X ), fun( X, bool ), set( X ), Z ) ) ),
% 1.56/1.93 hAPP( X, option( T ), hAPP( list( T ), fun( X, option( T ) ), hAPP( list
% 1.56/1.93 ( X ), fun( list( T ), fun( X, option( T ) ) ), hAPP( fun( X, option( T )
% 1.56/1.93 ), fun( list( X ), fun( list( T ), fun( X, option( T ) ) ) ), map_upds(
% 1.56/1.93 X, T ), U ), Z ), W ), Y ) = hAPP( X, option( T ), U, Y ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), Y ), Z )
% 1.56/1.93 ) ), hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), U ), W ) ) ) ), hAPP( fun(
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), fun( product_prod( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) )
% 1.56/1.93 ) ) ), bool ), transitive_rtrancl( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.93 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.93 ), product_prod( ty, product_prod( list( list( char ) ), exp( list( char
% 1.56/1.93 ) ) ) ) ) ) ) ) ) ) ), fun( product_prod( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, V0 ) ) ) ), hBOOL( hAPP
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool, hAPP( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), fun( fun( product_prod( product_prod
% 1.56/1.93 ( exp( list( char ) ), product_prod( fun( nat, option( product_prod( list
% 1.56/1.93 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.93 ) ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ) ), bool ), bool ), member(
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 hAPP( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), fun(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 product_Pair( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), Y ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), fun( list( char ), option( val ) ), hAPP( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( fun( list( char ), option( val ) ), fun( list( char
% 1.56/1.93 ), option( val ) ) ), map_add( list( char ), val ), V1 ), Z ) ) ) ),
% 1.56/1.93 hAPP( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), U ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), fun( list( char ), option( val ) ), hAPP( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( fun( list( char ), option( val ) ), fun( list( char
% 1.56/1.93 ), option( val ) ) ), map_add( list( char ), val ), V1 ), W ) ) ) ) ),
% 1.56/1.93 hAPP( fun( product_prod( product_prod( exp( list( char ) ), product_prod
% 1.56/1.93 ( fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) )
% 1.56/1.93 ) ) ), bool ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), transitive_rtrancl(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), red, V0 ) ) ) ) }.
% 1.56/1.93 { ! hAPP( X, option( Y ), Z, T ) = hAPP( Y, option( Y ), some( Y ), U ),
% 1.56/1.93 hAPP( X, option( Y ), hAPP( fun( X, option( Y ) ), fun( X, option( Y ) )
% 1.56/1.93 , hAPP( fun( X, option( Y ) ), fun( fun( X, option( Y ) ), fun( X, option
% 1.56/1.93 ( Y ) ) ), map_add( X, Y ), W ), Z ), T ) = hAPP( Y, option( Y ), some( Y
% 1.56/1.93 ), U ) }.
% 1.56/1.93 { hAPP( fun( X, option( Y ) ), fun( X, option( Y ) ), hAPP( fun( X, option
% 1.56/1.93 ( Y ) ), fun( fun( X, option( Y ) ), fun( X, option( Y ) ) ), map_add( X
% 1.56/1.93 , Y ), Z ), hAPP( fun( X, option( Y ) ), fun( X, option( Y ) ), hAPP( fun
% 1.56/1.93 ( X, option( Y ) ), fun( fun( X, option( Y ) ), fun( X, option( Y ) ) ),
% 1.56/1.93 map_add( X, Y ), T ), U ) ) = hAPP( fun( X, option( Y ) ), fun( X, option
% 1.56/1.93 ( Y ) ), hAPP( fun( X, option( Y ) ), fun( fun( X, option( Y ) ), fun( X
% 1.56/1.93 , option( Y ) ) ), map_add( X, Y ), hAPP( fun( X, option( Y ) ), fun( X,
% 1.56/1.93 option( Y ) ), hAPP( fun( X, option( Y ) ), fun( fun( X, option( Y ) ),
% 1.56/1.93 fun( X, option( Y ) ) ), map_add( X, Y ), Z ), T ) ), U ) }.
% 1.56/1.93 { hAPP( fun( X, option( Y ) ), fun( X, option( Y ) ), hAPP( fun( X, option
% 1.56/1.93 ( Y ) ), fun( fun( X, option( Y ) ), fun( X, option( Y ) ) ), map_add( X
% 1.56/1.93 , Y ), Z ), hAPP( list( Y ), fun( X, option( Y ) ), hAPP( list( X ), fun
% 1.56/1.93 ( list( Y ), fun( X, option( Y ) ) ), hAPP( fun( X, option( Y ) ), fun(
% 1.56/1.93 list( X ), fun( list( Y ), fun( X, option( Y ) ) ) ), map_upds( X, Y ), T
% 1.56/1.93 ), U ), W ) ) = hAPP( list( Y ), fun( X, option( Y ) ), hAPP( list( X )
% 1.56/1.93 , fun( list( Y ), fun( X, option( Y ) ) ), hAPP( fun( X, option( Y ) ),
% 1.56/1.93 fun( list( X ), fun( list( Y ), fun( X, option( Y ) ) ) ), map_upds( X, Y
% 1.56/1.93 ), hAPP( fun( X, option( Y ) ), fun( X, option( Y ) ), hAPP( fun( X,
% 1.56/1.93 option( Y ) ), fun( fun( X, option( Y ) ), fun( X, option( Y ) ) ),
% 1.56/1.93 map_add( X, Y ), Z ), T ) ), U ), W ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), Y ), Z )
% 1.56/1.93 ) ), hAPP( product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option(
% 1.56/1.93 val ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), hAPP( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( fun( list( char ), option( val ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_Pair( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ), U ), W ) ) ) ), hAPP( list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.93 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.93 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), red, V0 ) ) ), hBOOL( hAPP( fun( product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), X ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), Y ),
% 1.56/1.93 hAPP( fun( list( char ), option( val ) ), fun( list( char ), option( val
% 1.56/1.93 ) ), hAPP( fun( list( char ), option( val ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( list( char ), option( val ) ) ), map_add( list(
% 1.56/1.93 char ), val ), V1 ), Z ) ) ) ), hAPP( product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), T ), hAPP( fun( list( char ), option
% 1.56/1.93 ( val ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ), hAPP( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( fun( list( char ), option( val ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_Pair( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ), U ),
% 1.56/1.93 hAPP( fun( list( char ), option( val ) ), fun( list( char ), option( val
% 1.56/1.93 ) ), hAPP( fun( list( char ), option( val ) ), fun( fun( list( char ),
% 1.56/1.93 option( val ) ), fun( list( char ), option( val ) ) ), map_add( list(
% 1.56/1.93 char ), val ), V1 ), W ) ) ) ) ), hAPP( list( product_prod( list( char )
% 1.56/1.93 , product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.93 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.93 ), product_prod( ty, product_prod( list( list( char ) ), exp( list( char
% 1.56/1.93 ) ) ) ) ) ) ) ) ) ) ), fun( product_prod( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, V0 ) ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ), ! hAPP( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ), X, Z ) = hAPP( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ), option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ), some( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ),
% 1.56/1.93 hAPP( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), hAPP( list( char ), fun( fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ), product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ),
% 1.56/1.93 product_Pair( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), T ), U ) ), hAPP( nat, option( product_prod( list
% 1.56/1.93 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.93 ) ) ), Y, Z ) = hAPP( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ), some( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), hAPP( fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ), product_prod( list( char )
% 1.56/1.93 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ),
% 1.56/1.93 hAPP( list( char ), fun( fun( product_prod( list( char ), list( char ) )
% 1.56/1.93 , option( val ) ), product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), product_Pair( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ), T ),
% 1.56/1.93 skol38( Y, Z, T ) ) ) }.
% 1.56/1.93 { hAPP( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), X, skol64( X, Y ) ) = hAPP(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ), some(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), hAPP( fun( product_prod( list( char ), list(
% 1.56/1.93 char ) ), option( val ) ), product_prod( list( char ), fun( product_prod
% 1.56/1.93 ( list( char ), list( char ) ), option( val ) ) ), hAPP( list( char ),
% 1.56/1.93 fun( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), product_Pair( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), skol79( X, Y ) ), skol88
% 1.56/1.93 ( X, Y ) ) ), hBOOL( hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 bool, hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ) }
% 1.56/1.93 .
% 1.56/1.93 { ! hAPP( nat, option( product_prod( list( char ), fun( product_prod( list
% 1.56/1.93 ( char ), list( char ) ), option( val ) ) ) ), Y, skol64( X, Y ) ) = hAPP
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ), option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ), some(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), hAPP( fun( product_prod( list( char ), list(
% 1.56/1.93 char ) ), option( val ) ), product_prod( list( char ), fun( product_prod
% 1.56/1.93 ( list( char ), list( char ) ), option( val ) ) ), hAPP( list( char ),
% 1.56/1.93 fun( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), product_Pair( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), skol79( X, Y ) ), Z ) )
% 1.56/1.93 , hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), bool ), hext, X ), Y ) ), ! hAPP( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ), X, Z ) = hAPP( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ), option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ), some( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ),
% 1.56/1.93 hAPP( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), hAPP( list( char ), fun( fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ), product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ),
% 1.56/1.93 product_Pair( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), T ), U ) ), hAPP( nat, option( product_prod( list
% 1.56/1.93 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.93 ) ) ), Y, Z ) = hAPP( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ), some( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), hAPP( fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ), product_prod( list( char )
% 1.56/1.93 , fun( product_prod( list( char ), list( char ) ), option( val ) ) ),
% 1.56/1.93 hAPP( list( char ), fun( fun( product_prod( list( char ), list( char ) )
% 1.56/1.93 , option( val ) ), product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), product_Pair( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ), T ),
% 1.56/1.93 skol39( Y, Z, T ) ) ) }.
% 1.56/1.93 { hAPP( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ), Y, skol40( X, Y ) ) = hAPP(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ), option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ), some(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), hAPP( fun( product_prod( list( char ), list(
% 1.56/1.93 char ) ), option( val ) ), product_prod( list( char ), fun( product_prod
% 1.56/1.93 ( list( char ), list( char ) ), option( val ) ) ), hAPP( list( char ),
% 1.56/1.93 fun( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), product_Pair( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), skol65( X, Y ) ), skol80
% 1.56/1.93 ( X, Y ) ) ), hBOOL( hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 bool, hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), bool ), hext, Y ), X ) ) }
% 1.56/1.93 .
% 1.56/1.93 { ! hAPP( nat, option( product_prod( list( char ), fun( product_prod( list
% 1.56/1.93 ( char ), list( char ) ), option( val ) ) ) ), X, skol40( X, Y ) ) = hAPP
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ), option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ), some(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), hAPP( fun( product_prod( list( char ), list(
% 1.56/1.93 char ) ), option( val ) ), product_prod( list( char ), fun( product_prod
% 1.56/1.93 ( list( char ), list( char ) ), option( val ) ) ), hAPP( list( char ),
% 1.56/1.93 fun( fun( product_prod( list( char ), list( char ) ), option( val ) ),
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ), product_Pair( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ), skol65( X, Y ) ), Z ) )
% 1.56/1.93 , hBOOL( hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), bool,
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), bool ), hext, Y ), X ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), X ), Y ) ), hAPP( product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP
% 1.56/1.93 ( exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod
% 1.56/1.93 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), hAPP( val, exp( list( char ) ),
% 1.56/1.93 val_1( list( char ) ), Z ) ), T ) ) ), hAPP( fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), fun( product_prod( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat
% 1.56/1.93 , option( product_prod( list( char ), fun( product_prod( list( char ),
% 1.56/1.93 list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) )
% 1.56/1.93 ) ) ), bool ), transitive_rtrancl( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( char ), product_prod( list( product_prod( list(
% 1.56/1.93 char ), ty ) ), list( product_prod( list( char ), product_prod( list( ty
% 1.56/1.93 ), product_prod( ty, product_prod( list( list( char ) ), exp( list( char
% 1.56/1.93 ) ) ) ) ) ) ) ) ) ) ), fun( product_prod( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, U ) ) ) ), hBOOL( hAPP
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool, hAPP( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), fun( fun( product_prod( product_prod
% 1.56/1.93 ( exp( list( char ) ), product_prod( fun( nat, option( product_prod( list
% 1.56/1.93 ( char ), fun( product_prod( list( char ), list( char ) ), option( val )
% 1.56/1.93 ) ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ) ), bool ), bool ), member(
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 hAPP( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), fun(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ) ),
% 1.56/1.93 product_Pair( product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 , product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), hAPP
% 1.56/1.93 ( product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), exp( list(
% 1.56/1.93 char ) ), hAPP( list( char ), fun( exp( list( char ) ), exp( list( char )
% 1.56/1.93 ) ), hAPP( list( char ), fun( list( char ), fun( exp( list( char ) ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( exp( list( char ) ), fun( list( char ),
% 1.56/1.93 fun( list( char ), fun( exp( list( char ) ), exp( list( char ) ) ) ) ),
% 1.56/1.93 tryCatch( list( char ) ), X ), W ), V0 ), V1 ) ), Y ) ), hAPP(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( val, exp( list( char ) ), val_1
% 1.56/1.93 ( list( char ) ), Z ) ), T ) ) ), hAPP( fun( product_prod( product_prod(
% 1.56/1.93 exp( list( char ) ), product_prod( fun( nat, option( product_prod( list(
% 1.56/1.93 char ), fun( product_prod( list( char ), list( char ) ), option( val ) )
% 1.56/1.93 ) ) ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ) ), bool ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), transitive_rtrancl( product_prod( exp( list( char ) ), product_prod(
% 1.56/1.93 fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option
% 1.56/1.93 ( val ) ) ) ) ), hAPP( list( product_prod( list( char ), product_prod(
% 1.56/1.93 list( char ), product_prod( list( product_prod( list( char ), ty ) ),
% 1.56/1.93 list( product_prod( list( char ), product_prod( list( ty ), product_prod
% 1.56/1.93 ( ty, product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) )
% 1.56/1.93 ) ) ), fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), red, U ) ) ) ) }.
% 1.56/1.93 { ! hBOOL( hAPP( fun( product_prod( product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), X ), Y ) ), hAPP( product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP
% 1.56/1.93 ( exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod
% 1.56/1.93 ( list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), Z ), T ) ) ), hAPP( list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.93 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.93 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), red, U ) ) ), hBOOL( hAPP( fun( product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), bool ), bool, hAPP( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( fun( product_prod( product_prod( exp( list( char ) ), product_prod( fun
% 1.56/1.93 ( nat, option( product_prod( list( char ), fun( product_prod( list( char
% 1.56/1.93 ), list( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val
% 1.56/1.93 ) ) ) ), product_prod( exp( list( char ) ), product_prod( fun( nat,
% 1.56/1.93 option( product_prod( list( char ), fun( product_prod( list( char ), list
% 1.56/1.93 ( char ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) )
% 1.56/1.93 ), bool ), bool ), member( product_prod( product_prod( exp( list( char )
% 1.56/1.93 ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), hAPP( product_prod( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), product_prod( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), fun( product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), product_prod( product_prod( exp( list
% 1.56/1.93 ( char ) ), product_prod( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char ) )
% 1.56/1.93 , product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ) ), product_Pair( product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ), product_prod( exp( list( char
% 1.56/1.93 ) ), product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), hAPP( product_prod( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ), hAPP(
% 1.56/1.93 exp( list( char ) ), fun( product_prod( fun( nat, option( product_prod(
% 1.56/1.93 list( char ), fun( product_prod( list( char ), list( char ) ), option(
% 1.56/1.93 val ) ) ) ) ), fun( list( char ), option( val ) ) ), product_prod( exp(
% 1.56/1.93 list( char ) ), product_prod( fun( nat, option( product_prod( list( char
% 1.56/1.93 ), fun( product_prod( list( char ), list( char ) ), option( val ) ) ) )
% 1.56/1.93 ), fun( list( char ), option( val ) ) ) ) ), product_Pair( exp( list(
% 1.56/1.93 char ) ), product_prod( fun( nat, option( product_prod( list( char ), fun
% 1.56/1.93 ( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun
% 1.56/1.93 ( list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), exp( list
% 1.56/1.93 ( char ) ), hAPP( list( char ), fun( exp( list( char ) ), exp( list( char
% 1.56/1.93 ) ) ), hAPP( list( char ), fun( list( char ), fun( exp( list( char ) ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( exp( list( char ) ), fun( list( char ),
% 1.56/1.93 fun( list( char ), fun( exp( list( char ) ), exp( list( char ) ) ) ) ),
% 1.56/1.93 tryCatch( list( char ) ), X ), W ), V0 ), V1 ) ), Y ) ), hAPP(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), fun(
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ), product_prod( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ) ), product_Pair( exp( list( char ) ),
% 1.56/1.93 product_prod( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 list( char ), option( val ) ) ) ), hAPP( exp( list( char ) ), exp( list(
% 1.56/1.93 char ) ), hAPP( list( char ), fun( exp( list( char ) ), exp( list( char )
% 1.56/1.93 ) ), hAPP( list( char ), fun( list( char ), fun( exp( list( char ) ),
% 1.56/1.93 exp( list( char ) ) ) ), hAPP( exp( list( char ) ), fun( list( char ),
% 1.56/1.93 fun( list( char ), fun( exp( list( char ) ), exp( list( char ) ) ) ) ),
% 1.56/1.93 tryCatch( list( char ) ), Z ), W ), V0 ), V1 ) ), T ) ) ), hAPP( list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.93 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.93 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( product_prod(
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ),
% 1.56/1.93 product_prod( exp( list( char ) ), product_prod( fun( nat, option(
% 1.56/1.93 product_prod( list( char ), fun( product_prod( list( char ), list( char )
% 1.56/1.93 ), option( val ) ) ) ) ), fun( list( char ), option( val ) ) ) ) ), bool
% 1.56/1.93 ), red, U ) ) ) }.
% 1.56/1.93 { ti( X, ti( X, Y ) ) = ti( X, Y ) }.
% 1.56/1.93 { ! hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool ), fequal( X ), Y ), Z ) )
% 1.56/1.93 , ti( X, Y ) = ti( X, Z ) }.
% 1.56/1.93 { ! ti( X, Y ) = ti( X, Z ), hBOOL( hAPP( X, bool, hAPP( X, fun( X, bool )
% 1.56/1.93 , fequal( X ), Y ), Z ) ) }.
% 1.56/1.93 { hAPP( list( list( char ) ), nat, size_size( list( list( char ) ) ), vs_1
% 1.56/1.93 ) = hAPP( list( ty ), nat, size_size( list( ty ) ), ts ) }.
% 1.56/1.93 { hAPP( list( val ), nat, size_size( list( val ) ), vs ) = hAPP( list( ty )
% 1.56/1.93 , nat, size_size( list( ty ) ), ts ) }.
% 1.56/1.93 { alpha7, hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool )
% 1.56/1.93 , hAPP( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun
% 1.56/1.93 ( ty, bool ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list(
% 1.56/1.93 char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), hAPP( list( ty ), fun( list( char ), option( ty ) ), hAPP(
% 1.56/1.93 list( list( char ) ), fun( list( ty ), fun( list( char ), option( ty ) )
% 1.56/1.93 ), hAPP( fun( list( char ), option( ty ) ), fun( list( list( char ) ),
% 1.56/1.93 fun( list( ty ), fun( list( char ), option( ty ) ) ) ), map_upds( list(
% 1.56/1.93 char ), ty ), e_1 ), vs_1 ), ts ) ), e ), t ) ) }.
% 1.56/1.93 { alpha7, alpha2 }.
% 1.56/1.93 { alpha7, ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool
% 1.56/1.93 ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list( char ) ),
% 1.56/1.93 fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.93 , bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list
% 1.56/1.93 ( char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), e_1 ), hAPP( product_prod( list( list( char ) ), product_prod
% 1.56/1.93 ( list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ), exp(
% 1.56/1.93 list( char ) ), blocks, hAPP( product_prod( list( ty ), product_prod(
% 1.56/1.93 list( val ), exp( list( char ) ) ) ), product_prod( list( list( char ) )
% 1.56/1.93 , product_prod( list( ty ), product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ) ) ), hAPP( list( list( char ) ), fun( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ) ), product_Pair( list( list( char ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ) ), vs_1 ), hAPP( product_prod( list( val ), exp( list( char ) ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ), hAPP( list( ty ), fun( product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ), product_prod( list( ty ), product_prod( list( val ), exp( list(
% 1.56/1.93 char ) ) ) ) ), product_Pair( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ), ts ), hAPP( exp( list( char ) ), product_prod( list
% 1.56/1.93 ( val ), exp( list( char ) ) ), hAPP( list( val ), fun( exp( list( char )
% 1.56/1.93 ), product_prod( list( val ), exp( list( char ) ) ) ), product_Pair(
% 1.56/1.93 list( val ), exp( list( char ) ) ), vs ), e ) ) ) ) ), t ) ) }.
% 1.56/1.93 { ! alpha7, hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool
% 1.56/1.93 ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list( char ) ),
% 1.56/1.93 fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.93 , bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list
% 1.56/1.93 ( char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), e_1 ), hAPP( product_prod( list( list( char ) ), product_prod
% 1.56/1.93 ( list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ), exp(
% 1.56/1.93 list( char ) ), blocks, hAPP( product_prod( list( ty ), product_prod(
% 1.56/1.93 list( val ), exp( list( char ) ) ) ), product_prod( list( list( char ) )
% 1.56/1.93 , product_prod( list( ty ), product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ) ) ), hAPP( list( list( char ) ), fun( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ) ), product_Pair( list( list( char ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ) ), vs_1 ), hAPP( product_prod( list( val ), exp( list( char ) ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ), hAPP( list( ty ), fun( product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ), product_prod( list( ty ), product_prod( list( val ), exp( list(
% 1.56/1.93 char ) ) ) ) ), product_Pair( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ), ts ), hAPP( exp( list( char ) ), product_prod( list
% 1.56/1.93 ( val ), exp( list( char ) ) ), hAPP( list( val ), fun( exp( list( char )
% 1.56/1.93 ), product_prod( list( val ), exp( list( char ) ) ) ), product_Pair(
% 1.56/1.93 list( val ), exp( list( char ) ) ), vs ), e ) ) ) ) ), t ) ) }.
% 1.56/1.93 { ! alpha7, ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ), hAPP( fun( list( char ), option( ty ) ), fun( exp( list( char ) )
% 1.56/1.93 , fun( ty, bool ) ), hAPP( fun( nat, option( product_prod( list( char ),
% 1.56/1.93 fun( product_prod( list( char ), list( char ) ), option( val ) ) ) ) ),
% 1.56/1.93 fun( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty
% 1.56/1.93 , bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list
% 1.56/1.93 ( char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), hAPP( list( ty ), fun( list( char ), option( ty ) ), hAPP(
% 1.56/1.93 list( list( char ) ), fun( list( ty ), fun( list( char ), option( ty ) )
% 1.56/1.93 ), hAPP( fun( list( char ), option( ty ) ), fun( list( list( char ) ),
% 1.56/1.93 fun( list( ty ), fun( list( char ), option( ty ) ) ) ), map_upds( list(
% 1.56/1.93 char ), ty ), e_1 ), vs_1 ), ts ) ), e ), t ) ), ! alpha2 }.
% 1.56/1.93 { ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool ), hAPP
% 1.56/1.93 ( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list(
% 1.56/1.93 char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), e_1 ), hAPP( product_prod( list( list( char ) ), product_prod
% 1.56/1.93 ( list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ), exp(
% 1.56/1.93 list( char ) ), blocks, hAPP( product_prod( list( ty ), product_prod(
% 1.56/1.93 list( val ), exp( list( char ) ) ) ), product_prod( list( list( char ) )
% 1.56/1.93 , product_prod( list( ty ), product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ) ) ), hAPP( list( list( char ) ), fun( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ) ), product_Pair( list( list( char ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ) ), vs_1 ), hAPP( product_prod( list( val ), exp( list( char ) ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ), hAPP( list( ty ), fun( product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ), product_prod( list( ty ), product_prod( list( val ), exp( list(
% 1.56/1.93 char ) ) ) ) ), product_Pair( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ), ts ), hAPP( exp( list( char ) ), product_prod( list
% 1.56/1.93 ( val ), exp( list( char ) ) ), hAPP( list( val ), fun( exp( list( char )
% 1.56/1.93 ), product_prod( list( val ), exp( list( char ) ) ) ), product_Pair(
% 1.56/1.93 list( val ), exp( list( char ) ) ), vs ), e ) ) ) ) ), t ) ), hBOOL( hAPP
% 1.56/1.93 ( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool ), hAPP( fun( list(
% 1.56/1.93 char ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ), hAPP
% 1.56/1.93 ( fun( nat, option( product_prod( list( char ), fun( product_prod( list(
% 1.56/1.93 char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char ),
% 1.56/1.93 option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ), hAPP( list
% 1.56/1.93 ( product_prod( list( char ), product_prod( list( char ), product_prod(
% 1.56/1.93 list( product_prod( list( char ), ty ) ), list( product_prod( list( char
% 1.56/1.93 ), product_prod( list( ty ), product_prod( ty, product_prod( list( list
% 1.56/1.93 ( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) ), fun( fun( nat, option
% 1.56/1.93 ( product_prod( list( char ), fun( product_prod( list( char ), list( char
% 1.56/1.93 ) ), option( val ) ) ) ) ), fun( fun( list( char ), option( ty ) ), fun
% 1.56/1.93 ( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt, p ), h ), hAPP( list
% 1.56/1.93 ( ty ), fun( list( char ), option( ty ) ), hAPP( list( list( char ) ),
% 1.56/1.93 fun( list( ty ), fun( list( char ), option( ty ) ) ), hAPP( fun( list(
% 1.56/1.93 char ), option( ty ) ), fun( list( list( char ) ), fun( list( ty ), fun(
% 1.56/1.93 list( char ), option( ty ) ) ) ), map_upds( list( char ), ty ), e_1 ),
% 1.56/1.93 vs_1 ), ts ) ), e ), t ) ), alpha7 }.
% 1.56/1.93 { ! hBOOL( hAPP( ty, bool, hAPP( exp( list( char ) ), fun( ty, bool ), hAPP
% 1.56/1.93 ( fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 fun( list( char ), option( ty ) ), fun( exp( list( char ) ), fun( ty,
% 1.56/1.93 bool ) ) ), hAPP( list( product_prod( list( char ), product_prod( list(
% 1.56/1.93 char ), product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( fun( list( char
% 1.56/1.93 ), option( ty ) ), fun( exp( list( char ) ), fun( ty, bool ) ) ) ), wTrt
% 1.56/1.93 , p ), h ), e_1 ), hAPP( product_prod( list( list( char ) ), product_prod
% 1.56/1.93 ( list( ty ), product_prod( list( val ), exp( list( char ) ) ) ) ), exp(
% 1.56/1.93 list( char ) ), blocks, hAPP( product_prod( list( ty ), product_prod(
% 1.56/1.93 list( val ), exp( list( char ) ) ) ), product_prod( list( list( char ) )
% 1.56/1.93 , product_prod( list( ty ), product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ) ) ), hAPP( list( list( char ) ), fun( product_prod( list( ty ),
% 1.56/1.93 product_prod( list( val ), exp( list( char ) ) ) ), product_prod( list(
% 1.56/1.93 list( char ) ), product_prod( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ) ) ), product_Pair( list( list( char ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ) ), vs_1 ), hAPP( product_prod( list( val ), exp( list( char ) ) ),
% 1.56/1.93 product_prod( list( ty ), product_prod( list( val ), exp( list( char ) )
% 1.56/1.93 ) ), hAPP( list( ty ), fun( product_prod( list( val ), exp( list( char )
% 1.56/1.93 ) ), product_prod( list( ty ), product_prod( list( val ), exp( list(
% 1.56/1.93 char ) ) ) ) ), product_Pair( list( ty ), product_prod( list( val ), exp
% 1.56/1.93 ( list( char ) ) ) ), ts ), hAPP( exp( list( char ) ), product_prod( list
% 1.56/1.93 ( val ), exp( list( char ) ) ), hAPP( list( val ), fun( exp( list( char )
% 1.56/1.93 ), product_prod( list( val ), exp( list( char ) ) ) ), product_Pair(
% 1.56/1.93 list( val ), exp( list( char ) ) ), vs ), e ) ) ) ) ), t ) ), alpha2,
% 1.56/1.93 alpha7 }.
% 1.56/1.93 { ! alpha2, hAPP( list( val ), list( option( ty ) ), hAPP( fun( val, option
% 1.56/1.93 ( ty ) ), fun( list( val ), list( option( ty ) ) ), map( val, option( ty
% 1.56/1.93 ) ), hAPP( fun( nat, option( product_prod( list( char ), fun(
% 1.56/1.93 product_prod( list( char ), list( char ) ), option( val ) ) ) ) ), fun(
% 1.56/1.93 val, option( ty ) ), typeof_h, h ) ), vs ) = hAPP( list( ty ), list(
% 1.56/1.93 option( ty ) ), hAPP( fun( ty, option( ty ) ), fun( list( ty ), list(
% 1.56/1.93 option( ty ) ) ), map( ty, option( ty ) ), some( ty ) ), skol41 ) }.
% 1.56/1.93 { ! alpha2, hBOOL( hAPP( list( ty ), bool, hAPP( list( ty ), fun( list( ty
% 1.56/1.93 ), bool ), hAPP( fun( ty, fun( ty, bool ) ), fun( list( ty ), fun( list
% 1.56/1.93 ( ty ), bool ) ), list_all2( ty, ty ), hAPP( list( product_prod( list(
% 1.56/1.93 char ), product_prod( list( char ), product_prod( list( product_prod(
% 1.56/1.93 list( char ), ty ) ), list( product_prod( list( char ), product_prod(
% 1.56/1.93 list( ty ), product_prod( ty, product_prod( list( list( char ) ), exp(
% 1.56/1.93 list( char ) ) ) ) ) ) ) ) ) ) ), fun( ty, fun( ty, bool ) ), widen(
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ), p ) ),
% 1.56/1.93 skol41 ), ts ) ) }.
% 1.56/1.93 { ! hAPP( list( val ), list( option( ty ) ), hAPP( fun( val, option( ty ) )
% 1.56/1.93 , fun( list( val ), list( option( ty ) ) ), map( val, option( ty ) ),
% 1.56/1.93 hAPP( fun( nat, option( product_prod( list( char ), fun( product_prod(
% 1.56/1.93 list( char ), list( char ) ), option( val ) ) ) ) ), fun( val, option( ty
% 1.56/1.93 ) ), typeof_h, h ) ), vs ) = hAPP( list( ty ), list( option( ty ) ),
% 1.56/1.93 hAPP( fun( ty, option( ty ) ), fun( list( ty ), list( option( ty ) ) ),
% 1.56/1.93 map( ty, option( ty ) ), some( ty ) ), X ), ! hBOOL( hAPP( list( ty ),
% 1.56/1.93 bool, hAPP( list( ty ), fun( list( ty ), bool ), hAPP( fun( ty, fun( ty,
% 1.56/1.93 bool ) ), fun( list( ty ), fun( list( ty ), bool ) ), list_all2( ty, ty )
% 1.56/1.93 , hAPP( list( product_prod( list( char ), product_prod( list( char ),
% 1.56/1.93 product_prod( list( product_prod( list( char ), ty ) ), list(
% 1.56/1.93 product_prod( list( char ), product_prod( list( ty ), product_prod( ty,
% 1.56/1.93 product_prod( list( list( char ) ), exp( list( char ) ) ) ) ) ) ) ) ) ) )
% 1.56/1.93 , fun( ty, fun( ty, bool ) ), widen( product_prod( list( list( char ) ),
% 1.56/1.93 exp( list( char ) ) ) ), p ) ), X ), ts ) ), alpha2 }.
% 1.56/1.93
% 1.56/1.93 *** allocated 15000 integers for clauses
% 1.56/1.93 *** allocated 22500 integers for clauses
% 1.56/1.93 *** allocated 33750 integers for clauses
% 1.56/1.93 *** allocated 50625 integers for clauses
% 1.56/1.93 *** allocated 75937 integers for clauses
% 1.56/1.93 percentage equality = 0.352941, percentage horn = 0.848341
% 1.56/1.93 This is a problem with some equality
% 1.56/1.93
% 1.56/1.93
% 1.56/1.93
% 1.56/1.93 Options Used:
% 1.56/1.93
% 1.56/1.93 useres = 1
% 1.56/1.93 useparamod = 1
% 1.56/1.93 useeqrefl = 1
% 1.56/1.93 useeqfact = 1
% 1.56/1.93 usefactor = 1
% 1.56/1.93 usesimpsplitting = 0
% 1.56/1.93 usesimpdemod = 5
% 1.56/1.93 usesimpres = 3
% 1.56/1.93
% 1.56/1.93 resimpinuse = 1000
% 1.56/1.93 resimpclauses = 20000
% 1.56/1.93 substype = eqrewr
% 1.56/1.93 backwardsubs = 1
% 1.56/1.93 selectoldest = 5
% 1.56/1.93
% 1.56/1.93 litorderings [0] = split
% 1.56/1.93 litorderings [1] = extend the termordering, first sorting on arguments
% 1.56/1.93
% 1.56/1.93 termordering = kbo
% 1.56/1.93
% 1.56/1.93 litapriori = 0
% 1.56/1.93 termapriori = 1
% 1.56/1.93 litaposteriori = 0
% 1.56/1.93 termaposteriori = 0
% 1.56/1.93 demodaposteriori = 0
% 1.56/1.93 ordereqreflfact = 0
% 1.56/1.93
% 1.56/1.93 litselect = negord
% 1.56/1.93
% 1.56/1.93 maxweight = 15
% 1.56/1.93 maxdepth = 30000
% 1.56/1.93 maxlength = 115
% 1.56/1.93 maxnrvars = 195
% 1.56/1.93 excuselevel = 1
% 1.56/1.93 increasemaxweight = 1
% 1.56/1.93
% 1.56/1.93 maxselected = 10000000
% 1.56/1.93 maxnrclauses = 10000000
% 1.56/1.93
% 1.56/1.93 showgenerated = 0
% 1.56/1.93 showkept = 0
% 1.56/1.93 showselected = 0
% 1.56/1.93 showdeleted = 0
% 1.56/1.93 showresimp = 1
% 1.56/1.93 showstatus = 2000
% 1.56/1.93
% 1.56/1.93 prologoutput = 0
% 1.56/1.93 nrgoals = 5000000
% 1.56/1.93 totalproof = 1
% 1.56/1.93
% 1.56/1.93 Symbols occurring in the translation:
% 1.56/1.93
% 1.56/1.93 {} [0, 0] (w:1, o:2, a:1, s:1, b:0),
% 1.56/1.93 . [1, 2] (w:1, o:170, a:1, s:1, b:0),
% 1.56/1.93 ! [4, 1] (w:0, o:145, a:1, s:1, b:0),
% 1.56/1.93 = [13, 2] (w:1, o:0, a:0, s:1, b:0),
% 1.56/1.93 ==> [14, 2] (w:1, o:0, a:0, s:1, b:0),
% 1.56/1.93 char [35, 0] (w:1, o:10, a:1, s:1, b:0),
% 1.56/1.93 list [36, 1] (w:1, o:150, a:1, s:1, b:0),
% 1.56/1.93 ty [37, 0] (w:1, o:12, a:1, s:1, b:0),
% 1.56/1.93 product_prod [38, 2] (w:1, o:195, a:1, s:1, b:0),
% 1.56/1.93 exp [39, 1] (w:1, o:152, a:1, s:1, b:0),
% 1.56/1.93 nat [40, 0] (w:1, o:13, a:1, s:1, b:0),
% 1.56/1.93 val [41, 0] (w:1, o:14, a:1, s:1, b:0),
% 1.56/1.93 option [42, 1] (w:1, o:153, a:1, s:1, b:0),
% 1.56/1.93 fun [43, 2] (w:1, o:196, a:1, s:1, b:0),
% 1.56/1.93 bool [44, 0] (w:1, o:8, a:1, s:1, b:0),
% 1.56/1.93 eval [45, 0] (w:1, o:15, a:1, s:1, b:0),
% 1.56/1.93 ti [46, 2] (w:1, o:205, a:1, s:1, b:0),
% 1.56/1.93 final [47, 1] (w:1, o:154, a:1, s:1, b:0),
% 1.56/1.93 conf [49, 1] (w:1, o:155, a:1, s:1, b:0),
% 1.56/1.93 hconf [50, 1] (w:1, o:156, a:1, s:1, b:0),
% 1.56/1.93 lconf [51, 1] (w:1, o:157, a:1, s:1, b:0),
% 1.56/1.93 tryCatch [52, 1] (w:1, o:161, a:1, s:1, b:0),
% 1.56/1.93 val_1 [53, 1] (w:1, o:165, a:1, s:1, b:0),
% 1.56/1.93 comp [56, 3] (w:1, o:211, a:1, s:1, b:0),
% 1.56/1.93 override_on [57, 2] (w:1, o:194, a:1, s:1, b:0),
% 1.56/1.93 undefined [58, 1] (w:1, o:164, a:1, s:1, b:0),
% 1.56/1.93 distinct [59, 1] (w:1, o:151, a:1, s:1, b:0),
% 1.56/1.93 list_all2 [60, 2] (w:1, o:206, a:1, s:1, b:0),
% 1.56/1.93 map [61, 2] (w:1, o:207, a:1, s:1, b:0),
% 1.56/1.93 set [62, 1] (w:1, o:158, a:1, s:1, b:0),
% 1.56/1.93 map_add [63, 2] (w:1, o:208, a:1, s:1, b:0),
% 1.56/1.93 map_upds [64, 2] (w:1, o:209, a:1, s:1, b:0),
% 1.56/1.93 size_size [65, 1] (w:1, o:159, a:1, s:1, b:0),
% 1.56/1.93 hext [66, 0] (w:1, o:19, a:1, s:1, b:0),
% 1.56/1.93 typeof_h [67, 0] (w:1, o:20, a:1, s:1, b:0),
% 1.56/1.93 some [68, 1] (w:1, o:160, a:1, s:1, b:0),
% 1.56/1.93 the [69, 1] (w:1, o:162, a:1, s:1, b:0),
% 1.56/1.93 product_Pair [72, 2] (w:1, o:210, a:1, s:1, b:0),
% 1.56/1.93 product_curry [73, 3] (w:1, o:212, a:1, s:1, b:0),
% 1.56/1.93 produc1605651328_split [74, 3] (w:1, o:213, a:1, s:1, b:0),
% 1.56/1.93 product_prod_rec [75, 3] (w:1, o:214, a:1, s:1, b:0),
% 1.56/1.93 blocks [76, 0] (w:1, o:9, a:1, s:1, b:0),
% 1.56/1.93 red [77, 0] (w:1, o:24, a:1, s:1, b:0),
% 1.56/1.93 transitive_rtrancl [78, 1] (w:1, o:163, a:1, s:1, b:0),
% 1.56/1.93 widen [79, 1] (w:1, o:166, a:1, s:1, b:0),
% 1.56/1.93 wTrt [80, 0] (w:1, o:27, a:1, s:1, b:0),
% 1.56/1.93 wTrts [81, 0] (w:1, o:28, a:1, s:1, b:0),
% 1.56/1.93 fequal [82, 1] (w:1, o:167, a:1, s:1, b:0),
% 1.56/1.93 hAPP [85, 4] (w:1, o:230, a:1, s:1, b:0),
% 1.56/1.93 hBOOL [86, 1] (w:1, o:168, a:1, s:1, b:0),
% 1.56/1.93 member [87, 1] (w:1, o:169, a:1, s:1, b:0),
% 1.56/1.93 e_1 [88, 0] (w:1, o:43, a:1, s:1, b:0),
% 1.56/1.93 p [89, 0] (w:1, o:44, a:1, s:1, b:0),
% 1.56/1.93 t [90, 0] (w:1, o:45, a:1, s:1, b:0),
% 1.56/1.93 ts [91, 0] (w:1, o:46, a:1, s:1, b:0),
% 1.56/1.93 vs_1 [92, 0] (w:1, o:25, a:1, s:1, b:0),
% 1.56/1.93 e [93, 0] (w:1, o:47, a:1, s:1, b:0),
% 1.56/1.93 h [94, 0] (w:1, o:48, a:1, s:1, b:0),
% 1.56/1.93 vs [95, 0] (w:1, o:26, a:1, s:1, b:0),
% 1.56/1.93 alpha1 [205, 6] (w:1, o:266, a:1, s:1, b:1),
% 1.56/1.93 alpha2 [206, 0] (w:1, o:6, a:1, s:1, b:1),
% 1.56/1.93 alpha3 [207, 6] (w:1, o:267, a:1, s:1, b:1),
% 1.56/1.93 alpha4 [208, 9] (w:1, o:305, a:1, s:1, b:1),
% 1.56/1.93 alpha5 [209, 5] (w:1, o:250, a:1, s:1, b:1),
% 1.56/1.93 alpha6 [210, 4] (w:1, o:231, a:1, s:1, b:1),
% 1.56/1.93 alpha7 [211, 0] (w:1, o:7, a:1, s:1, b:1),
% 1.56/1.93 skol1 [212, 7] (w:1, o:290, a:1, s:1, b:1),
% 1.56/1.93 skol2 [213, 7] (w:1, o:291, a:1, s:1, b:1),
% 1.56/1.93 skol3 [214, 6] (w:1, o:271, a:1, s:1, b:1),
% 1.56/1.93 skol4 [215, 6] (w:1, o:273, a:1, s:1, b:1),
% 1.56/1.93 skol5 [216, 5] (w:1, o:253, a:1, s:1, b:1),
% 1.56/1.93 skol6 [217, 5] (w:1, o:254, a:1, s:1, b:1),
% 1.56/1.93 skol7 [218, 3] (w:1, o:215, a:1, s:1, b:1),
% 1.56/1.93 skol8 [219, 4] (w:1, o:235, a:1, s:1, b:1),
% 1.56/1.93 skol9 [220, 4] (w:1, o:236, a:1, s:1, b:1),
% 1.56/1.93 skol10 [221, 5] (w:1, o:255, a:1, s:1, b:1),
% 1.56/1.93 skol11 [222, 4] (w:1, o:237, a:1, s:1, b:1),
% 1.56/1.93 skol12 [223, 2] (w:1, o:197, a:1, s:1, b:1),
% 1.56/1.93 skol13 [224, 3] (w:1, o:216, a:1, s:1, b:1),
% 1.56/1.93 skol14 [225, 6] (w:1, o:274, a:1, s:1, b:1),
% 1.56/1.93 skol15 [226, 2] (w:1, o:198, a:1, s:1, b:1),
% 70.71/71.18 skol16 [227, 5] (w:1, o:256, a:1, s:1, b:1),
% 70.71/71.18 skol17 [228, 3] (w:1, o:217, a:1, s:1, b:1),
% 70.71/71.18 skol18 [229, 3] (w:1, o:218, a:1, s:1, b:1),
% 70.71/71.18 skol19 [230, 3] (w:1, o:219, a:1, s:1, b:1),
% 70.71/71.18 skol20 [231, 8] (w:1, o:304, a:1, s:1, b:1),
% 70.71/71.18 skol21 [232, 6] (w:1, o:268, a:1, s:1, b:1),
% 70.71/71.18 skol22 [233, 6] (w:1, o:269, a:1, s:1, b:1),
% 70.71/71.18 skol23 [234, 6] (w:1, o:270, a:1, s:1, b:1),
% 70.71/71.18 skol24 [235, 7] (w:1, o:292, a:1, s:1, b:1),
% 70.71/71.18 skol25 [236, 4] (w:1, o:238, a:1, s:1, b:1),
% 70.71/71.18 skol26 [237, 4] (w:1, o:239, a:1, s:1, b:1),
% 70.71/71.18 skol27 [238, 4] (w:1, o:240, a:1, s:1, b:1),
% 70.71/71.18 skol28 [239, 4] (w:1, o:241, a:1, s:1, b:1),
% 70.71/71.18 skol29 [240, 4] (w:1, o:242, a:1, s:1, b:1),
% 70.71/71.18 skol30 [241, 5] (w:1, o:257, a:1, s:1, b:1),
% 70.71/71.18 skol31 [242, 4] (w:1, o:243, a:1, s:1, b:1),
% 70.71/71.18 skol32 [243, 5] (w:1, o:258, a:1, s:1, b:1),
% 70.71/71.18 skol33 [244, 6] (w:1, o:272, a:1, s:1, b:1),
% 70.71/71.18 skol34 [245, 4] (w:1, o:244, a:1, s:1, b:1),
% 70.71/71.18 skol35 [246, 5] (w:1, o:259, a:1, s:1, b:1),
% 70.71/71.18 skol36 [247, 5] (w:1, o:260, a:1, s:1, b:1),
% 70.71/71.18 skol37 [248, 3] (w:1, o:220, a:1, s:1, b:1),
% 70.71/71.18 skol38 [249, 3] (w:1, o:221, a:1, s:1, b:1),
% 70.71/71.18 skol39 [250, 3] (w:1, o:222, a:1, s:1, b:1),
% 70.71/71.18 skol40 [251, 2] (w:1, o:199, a:1, s:1, b:1),
% 70.71/71.18 skol41 [252, 0] (w:1, o:11, a:1, s:1, b:1),
% 70.71/71.18 skol42 [253, 7] (w:1, o:293, a:1, s:1, b:1),
% 70.71/71.18 skol43 [254, 7] (w:1, o:294, a:1, s:1, b:1),
% 70.71/71.18 skol44 [255, 6] (w:1, o:275, a:1, s:1, b:1),
% 70.71/71.18 skol45 [256, 6] (w:1, o:276, a:1, s:1, b:1),
% 70.71/71.18 skol46 [257, 5] (w:1, o:251, a:1, s:1, b:1),
% 70.71/71.18 skol47 [258, 5] (w:1, o:252, a:1, s:1, b:1),
% 70.71/71.18 skol48 [259, 3] (w:1, o:223, a:1, s:1, b:1),
% 70.71/71.18 skol49 [260, 4] (w:1, o:245, a:1, s:1, b:1),
% 70.71/71.18 skol50 [261, 4] (w:1, o:246, a:1, s:1, b:1),
% 70.71/71.18 skol51 [262, 4] (w:1, o:247, a:1, s:1, b:1),
% 70.71/71.18 skol52 [263, 3] (w:1, o:224, a:1, s:1, b:1),
% 70.71/71.18 skol53 [264, 6] (w:1, o:277, a:1, s:1, b:1),
% 70.71/71.18 skol54 [265, 3] (w:1, o:225, a:1, s:1, b:1),
% 70.71/71.18 skol55 [266, 3] (w:1, o:226, a:1, s:1, b:1),
% 70.71/71.18 skol56 [267, 3] (w:1, o:227, a:1, s:1, b:1),
% 70.71/71.18 skol57 [268, 6] (w:1, o:278, a:1, s:1, b:1),
% 70.71/71.18 skol58 [269, 6] (w:1, o:279, a:1, s:1, b:1),
% 70.71/71.18 skol59 [270, 6] (w:1, o:280, a:1, s:1, b:1),
% 70.71/71.18 skol60 [271, 7] (w:1, o:295, a:1, s:1, b:1),
% 70.71/71.18 skol61 [272, 4] (w:1, o:248, a:1, s:1, b:1),
% 70.71/71.18 skol62 [273, 5] (w:1, o:261, a:1, s:1, b:1),
% 70.71/71.18 skol63 [274, 4] (w:1, o:249, a:1, s:1, b:1),
% 70.71/71.18 skol64 [275, 2] (w:1, o:200, a:1, s:1, b:1),
% 70.71/71.18 skol65 [276, 2] (w:1, o:201, a:1, s:1, b:1),
% 70.71/71.18 skol66 [277, 7] (w:1, o:296, a:1, s:1, b:1),
% 70.71/71.18 skol67 [278, 7] (w:1, o:297, a:1, s:1, b:1),
% 70.71/71.18 skol68 [279, 6] (w:1, o:281, a:1, s:1, b:1),
% 70.71/71.18 skol69 [280, 6] (w:1, o:282, a:1, s:1, b:1),
% 70.71/71.18 skol70 [281, 5] (w:1, o:262, a:1, s:1, b:1),
% 70.71/71.18 skol71 [282, 5] (w:1, o:263, a:1, s:1, b:1),
% 70.71/71.18 skol72 [283, 3] (w:1, o:228, a:1, s:1, b:1),
% 70.71/71.18 skol73 [284, 4] (w:1, o:232, a:1, s:1, b:1),
% 70.71/71.18 skol74 [285, 4] (w:1, o:233, a:1, s:1, b:1),
% 70.71/71.18 skol75 [286, 6] (w:1, o:283, a:1, s:1, b:1),
% 70.71/71.18 skol76 [287, 3] (w:1, o:229, a:1, s:1, b:1),
% 70.71/71.18 skol77 [288, 6] (w:1, o:284, a:1, s:1, b:1),
% 70.71/71.18 skol78 [289, 4] (w:1, o:234, a:1, s:1, b:1),
% 70.71/71.18 skol79 [290, 2] (w:1, o:202, a:1, s:1, b:1),
% 70.71/71.18 skol80 [291, 2] (w:1, o:203, a:1, s:1, b:1),
% 70.71/71.18 skol81 [292, 7] (w:1, o:298, a:1, s:1, b:1),
% 70.71/71.18 skol82 [293, 7] (w:1, o:299, a:1, s:1, b:1),
% 70.71/71.18 skol83 [294, 6] (w:1, o:285, a:1, s:1, b:1),
% 70.71/71.18 skol84 [295, 6] (w:1, o:286, a:1, s:1, b:1),
% 70.71/71.18 skol85 [296, 5] (w:1, o:264, a:1, s:1, b:1),
% 70.71/71.18 skol86 [297, 5] (w:1, o:265, a:1, s:1, b:1),
% 70.71/71.18 skol87 [298, 6] (w:1, o:287, a:1, s:1, b:1),
% 70.71/71.18 skol88 [299, 2] (w:1, o:204, a:1, s:1, b:1),
% 70.71/71.18 skol89 [300, 7] (w:1, o:300, a:1, s:1, b:1),
% 70.71/71.18 skol90 [301, 7] (w:1, o:301, a:1, s:1, b:1),
% 70.71/71.18 skol91 [302, 6] (w:1, o:288, a:1, s:1, b:1),
% 70.71/71.18 skol92 [303, 6] (w:1, o:289, a:1, s:1, b:1),
% 70.71/71.18 skol93 [304, 7] (w:1, o:302, a:1, s:1, b:1),
% 70.71/71.18 skoCputime limit exceeded (core dumped)
%------------------------------------------------------------------------------