{-# LANGUAGE BangPatterns #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE Strict #-} {-# LANGUAGE StrictData #-} {-# LANGUAGE ViewPatterns #-} module Backend.Reader where import Control.Monad.Except import Control.Parallel import Environment import Core.Primitives as Primitives import Backend.Utils import Core.Types import Core.Utils import Wrap import Backend.Toplevel import Backend.Core import Backend.Sys import Backend.Sequent import Backend.Yacc {- Copyright (c) 2015, Mark Tarver All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The name of Mark Tarver may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY Mark Tarver ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Mark Tarver BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -} kl_read_char_code :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_char_code (!kl_V2163) = do kl_V2163 `pseq` readByte kl_V2163 kl_read_file_as_bytelist :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_file_as_bytelist (!kl_V2165) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_S) -> do kl_S `pseq` readByte kl_S))) kl_V2165 `pseq` (appl_0 `pseq` kl_shen_read_file_as_Xlist kl_V2165 appl_0) kl_read_file_as_charlist :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_file_as_charlist (!kl_V2167) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_S) -> do kl_S `pseq` kl_read_char_code kl_S))) kl_V2167 `pseq` (appl_0 `pseq` kl_shen_read_file_as_Xlist kl_V2167 appl_0) kl_shen_read_file_as_Xlist :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_read_file_as_Xlist (!kl_V2170) (!kl_V2171) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Stream) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_X) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Xs) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Close) -> do kl_Xs `pseq` kl_reverse kl_Xs))) !appl_4 <- kl_Stream `pseq` closeStream kl_Stream appl_4 `pseq` applyWrapper appl_3 [appl_4]))) let !appl_5 = Atom Nil !appl_6 <- kl_Stream `pseq` (kl_V2171 `pseq` (kl_X `pseq` (appl_5 `pseq` kl_shen_read_file_as_Xlist_help kl_Stream kl_V2171 kl_X appl_5))) appl_6 `pseq` applyWrapper appl_2 [appl_6]))) !appl_7 <- kl_Stream `pseq` applyWrapper kl_V2171 [kl_Stream] appl_7 `pseq` applyWrapper appl_1 [appl_7]))) !appl_8 <- kl_V2170 `pseq` openStream kl_V2170 (Core.Types.Atom (Core.Types.UnboundSym "in")) appl_8 `pseq` applyWrapper appl_0 [appl_8] kl_shen_read_file_as_Xlist_help :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_read_file_as_Xlist_help (!kl_V2176) (!kl_V2177) (!kl_V2178) (!kl_V2179) = do let pat_cond_0 = do return kl_V2179 pat_cond_1 = do do !appl_2 <- kl_V2176 `pseq` applyWrapper kl_V2177 [kl_V2176] !appl_3 <- kl_V2178 `pseq` (kl_V2179 `pseq` klCons kl_V2178 kl_V2179) kl_V2176 `pseq` (kl_V2177 `pseq` (appl_2 `pseq` (appl_3 `pseq` kl_shen_read_file_as_Xlist_help kl_V2176 kl_V2177 appl_2 appl_3))) in case kl_V2178 of kl_V2178@(Atom (N (KI (-1)))) -> pat_cond_0 _ -> pat_cond_1 kl_read_file_as_string :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_file_as_string (!kl_V2181) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Stream) -> do !appl_1 <- kl_Stream `pseq` kl_read_char_code kl_Stream kl_Stream `pseq` (appl_1 `pseq` kl_shen_rfas_h kl_Stream appl_1 (Core.Types.Atom (Core.Types.Str "")))))) !appl_2 <- kl_V2181 `pseq` openStream kl_V2181 (Core.Types.Atom (Core.Types.UnboundSym "in")) appl_2 `pseq` applyWrapper appl_0 [appl_2] kl_shen_rfas_h :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_rfas_h (!kl_V2185) (!kl_V2186) (!kl_V2187) = do let pat_cond_0 = do !appl_1 <- kl_V2185 `pseq` closeStream kl_V2185 appl_1 `pseq` (kl_V2187 `pseq` kl_do appl_1 kl_V2187) pat_cond_2 = do do !appl_3 <- kl_V2185 `pseq` kl_read_char_code kl_V2185 !appl_4 <- kl_V2186 `pseq` nToString kl_V2186 !appl_5 <- kl_V2187 `pseq` (appl_4 `pseq` cn kl_V2187 appl_4) kl_V2185 `pseq` (appl_3 `pseq` (appl_5 `pseq` kl_shen_rfas_h kl_V2185 appl_3 appl_5)) in case kl_V2186 of kl_V2186@(Atom (N (KI (-1)))) -> pat_cond_0 _ -> pat_cond_2 kl_input :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_input (!kl_V2189) = do !appl_0 <- kl_V2189 `pseq` kl_read kl_V2189 appl_0 `pseq` evalKL appl_0 kl_inputPlus :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_inputPlus (!kl_V2192) (!kl_V2193) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_MonoP) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_Input) -> do let !aw_2 = Core.Types.Atom (Core.Types.UnboundSym "shen.demodulate") !appl_3 <- kl_V2192 `pseq` applyWrapper aw_2 [kl_V2192] let !aw_4 = Core.Types.Atom (Core.Types.UnboundSym "shen.typecheck") !appl_5 <- kl_Input `pseq` (appl_3 `pseq` applyWrapper aw_4 [kl_Input, appl_3]) !kl_if_6 <- appl_5 `pseq` eq (Atom (B False)) appl_5 case kl_if_6 of Atom (B (True)) -> do let !aw_7 = Core.Types.Atom (Core.Types.UnboundSym "shen.app") !appl_8 <- kl_V2192 `pseq` applyWrapper aw_7 [kl_V2192, Core.Types.Atom (Core.Types.Str "\n"), Core.Types.Atom (Core.Types.UnboundSym "shen.r")] !appl_9 <- appl_8 `pseq` cn (Core.Types.Atom (Core.Types.Str " is not of type ")) appl_8 let !aw_10 = Core.Types.Atom (Core.Types.UnboundSym "shen.app") !appl_11 <- kl_Input `pseq` (appl_9 `pseq` applyWrapper aw_10 [kl_Input, appl_9, Core.Types.Atom (Core.Types.UnboundSym "shen.r")]) !appl_12 <- appl_11 `pseq` cn (Core.Types.Atom (Core.Types.Str "type error: ")) appl_11 appl_12 `pseq` simpleError appl_12 Atom (B (False)) -> do do kl_Input `pseq` evalKL kl_Input _ -> throwError "if: expected boolean"))) !appl_13 <- kl_V2193 `pseq` kl_read kl_V2193 appl_13 `pseq` applyWrapper appl_1 [appl_13]))) !appl_14 <- kl_V2192 `pseq` kl_shen_monotype kl_V2192 appl_14 `pseq` applyWrapper appl_0 [appl_14] kl_shen_monotype :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_monotype (!kl_V2195) = do let pat_cond_0 kl_V2195 kl_V2195h kl_V2195t = do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_Z) -> do kl_Z `pseq` kl_shen_monotype kl_Z))) appl_1 `pseq` (kl_V2195 `pseq` kl_map appl_1 kl_V2195) pat_cond_2 = do do !kl_if_3 <- kl_V2195 `pseq` kl_variableP kl_V2195 case kl_if_3 of Atom (B (True)) -> do let !aw_4 = Core.Types.Atom (Core.Types.UnboundSym "shen.app") !appl_5 <- kl_V2195 `pseq` applyWrapper aw_4 [kl_V2195, Core.Types.Atom (Core.Types.Str "\n"), Core.Types.Atom (Core.Types.UnboundSym "shen.a")] !appl_6 <- appl_5 `pseq` cn (Core.Types.Atom (Core.Types.Str "input+ expects a monotype: not ")) appl_5 appl_6 `pseq` simpleError appl_6 Atom (B (False)) -> do do return kl_V2195 _ -> throwError "if: expected boolean" in case kl_V2195 of !(kl_V2195@(Cons (!kl_V2195h) (!kl_V2195t))) -> pat_cond_0 kl_V2195 kl_V2195h kl_V2195t _ -> pat_cond_2 kl_read :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read (!kl_V2197) = do !appl_0 <- kl_V2197 `pseq` kl_read_char_code kl_V2197 let !appl_1 = Atom Nil !appl_2 <- kl_V2197 `pseq` (appl_0 `pseq` (appl_1 `pseq` kl_shen_read_loop kl_V2197 appl_0 appl_1)) appl_2 `pseq` hd appl_2 kl_it :: Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_it = do value (Core.Types.Atom (Core.Types.UnboundSym "shen.*it*")) kl_shen_read_loop :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_read_loop (!kl_V2205) (!kl_V2206) (!kl_V2207) = do let pat_cond_0 = do simpleError (Core.Types.Atom (Core.Types.Str "read aborted")) pat_cond_1 = do !kl_if_2 <- kl_V2207 `pseq` kl_emptyP kl_V2207 case kl_if_2 of Atom (B (True)) -> do simpleError (Core.Types.Atom (Core.Types.Str "error: empty stream")) Atom (B (False)) -> do do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_E) -> do return kl_E))) appl_3 `pseq` (kl_V2207 `pseq` (appl_4 `pseq` kl_compile appl_3 kl_V2207 appl_4)) _ -> throwError "if: expected boolean" pat_cond_5 = do !kl_if_6 <- kl_V2206 `pseq` kl_shen_terminatorP kl_V2206 case kl_if_6 of Atom (B (True)) -> do let !appl_7 = ApplC (Func "lambda" (Context (\(!kl_AllChars) -> do let !appl_8 = ApplC (Func "lambda" (Context (\(!kl_It) -> do let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Read) -> do !kl_if_10 <- let pat_cond_11 = do return (Atom (B True)) pat_cond_12 = do do !kl_if_13 <- kl_Read `pseq` kl_emptyP kl_Read case kl_if_13 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" in case kl_Read of kl_Read@(Atom (UnboundSym "shen.nextbyte")) -> pat_cond_11 kl_Read@(ApplC (PL "shen.nextbyte" _)) -> pat_cond_11 kl_Read@(ApplC (Func "shen.nextbyte" _)) -> pat_cond_11 _ -> pat_cond_12 case kl_if_10 of Atom (B (True)) -> do !appl_14 <- kl_V2205 `pseq` kl_read_char_code kl_V2205 kl_V2205 `pseq` (appl_14 `pseq` (kl_AllChars `pseq` kl_shen_read_loop kl_V2205 appl_14 kl_AllChars)) Atom (B (False)) -> do do return kl_Read _ -> throwError "if: expected boolean"))) let !appl_15 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_16 = ApplC (Func "lambda" (Context (\(!kl_E) -> do return (Core.Types.Atom (Core.Types.UnboundSym "shen.nextbyte"))))) !appl_17 <- appl_15 `pseq` (kl_AllChars `pseq` (appl_16 `pseq` kl_compile appl_15 kl_AllChars appl_16)) appl_17 `pseq` applyWrapper appl_9 [appl_17]))) !appl_18 <- kl_AllChars `pseq` kl_shen_record_it kl_AllChars appl_18 `pseq` applyWrapper appl_8 [appl_18]))) let !appl_19 = Atom Nil !appl_20 <- kl_V2206 `pseq` (appl_19 `pseq` klCons kl_V2206 appl_19) !appl_21 <- kl_V2207 `pseq` (appl_20 `pseq` kl_append kl_V2207 appl_20) appl_21 `pseq` applyWrapper appl_7 [appl_21] Atom (B (False)) -> do do !appl_22 <- kl_V2205 `pseq` kl_read_char_code kl_V2205 let !appl_23 = Atom Nil !appl_24 <- kl_V2206 `pseq` (appl_23 `pseq` klCons kl_V2206 appl_23) !appl_25 <- kl_V2207 `pseq` (appl_24 `pseq` kl_append kl_V2207 appl_24) kl_V2205 `pseq` (appl_22 `pseq` (appl_25 `pseq` kl_shen_read_loop kl_V2205 appl_22 appl_25)) _ -> throwError "if: expected boolean" in case kl_V2206 of kl_V2206@(Atom (N (KI 94))) -> pat_cond_0 kl_V2206@(Atom (N (KI (-1)))) -> pat_cond_1 _ -> pat_cond_5 kl_shen_terminatorP :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_terminatorP (!kl_V2209) = do let !appl_0 = Atom Nil !appl_1 <- appl_0 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 93))) appl_0 !appl_2 <- appl_1 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 41))) appl_1 !appl_3 <- appl_2 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 34))) appl_2 !appl_4 <- appl_3 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 32))) appl_3 !appl_5 <- appl_4 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 13))) appl_4 !appl_6 <- appl_5 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_5 !appl_7 <- appl_6 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 9))) appl_6 kl_V2209 `pseq` (appl_7 `pseq` kl_elementP kl_V2209 appl_7) kl_lineread :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_lineread (!kl_V2211) = do !appl_0 <- kl_V2211 `pseq` kl_read_char_code kl_V2211 let !appl_1 = Atom Nil appl_0 `pseq` (appl_1 `pseq` (kl_V2211 `pseq` kl_shen_lineread_loop appl_0 appl_1 kl_V2211)) kl_shen_lineread_loop :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_lineread_loop (!kl_V2216) (!kl_V2217) (!kl_V2218) = do let pat_cond_0 = do !kl_if_1 <- kl_V2217 `pseq` kl_emptyP kl_V2217 case kl_if_1 of Atom (B (True)) -> do simpleError (Core.Types.Atom (Core.Types.Str "empty stream")) Atom (B (False)) -> do do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_E) -> do return kl_E))) appl_2 `pseq` (kl_V2217 `pseq` (appl_3 `pseq` kl_compile appl_2 kl_V2217 appl_3)) _ -> throwError "if: expected boolean" pat_cond_4 = do !appl_5 <- kl_shen_hat !kl_if_6 <- kl_V2216 `pseq` (appl_5 `pseq` eq kl_V2216 appl_5) case kl_if_6 of Atom (B (True)) -> do simpleError (Core.Types.Atom (Core.Types.Str "line read aborted")) Atom (B (False)) -> do !appl_7 <- kl_shen_newline !appl_8 <- kl_shen_carriage_return let !appl_9 = Atom Nil !appl_10 <- appl_8 `pseq` (appl_9 `pseq` klCons appl_8 appl_9) !appl_11 <- appl_7 `pseq` (appl_10 `pseq` klCons appl_7 appl_10) !kl_if_12 <- kl_V2216 `pseq` (appl_11 `pseq` kl_elementP kl_V2216 appl_11) case kl_if_12 of Atom (B (True)) -> do let !appl_13 = ApplC (Func "lambda" (Context (\(!kl_Line) -> do let !appl_14 = ApplC (Func "lambda" (Context (\(!kl_It) -> do !kl_if_15 <- let pat_cond_16 = do return (Atom (B True)) pat_cond_17 = do do !kl_if_18 <- kl_Line `pseq` kl_emptyP kl_Line case kl_if_18 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" in case kl_Line of kl_Line@(Atom (UnboundSym "shen.nextline")) -> pat_cond_16 kl_Line@(ApplC (PL "shen.nextline" _)) -> pat_cond_16 kl_Line@(ApplC (Func "shen.nextline" _)) -> pat_cond_16 _ -> pat_cond_17 case kl_if_15 of Atom (B (True)) -> do !appl_19 <- kl_V2218 `pseq` kl_read_char_code kl_V2218 let !appl_20 = Atom Nil !appl_21 <- kl_V2216 `pseq` (appl_20 `pseq` klCons kl_V2216 appl_20) !appl_22 <- kl_V2217 `pseq` (appl_21 `pseq` kl_append kl_V2217 appl_21) appl_19 `pseq` (appl_22 `pseq` (kl_V2218 `pseq` kl_shen_lineread_loop appl_19 appl_22 kl_V2218)) Atom (B (False)) -> do do return kl_Line _ -> throwError "if: expected boolean"))) !appl_23 <- kl_V2217 `pseq` kl_shen_record_it kl_V2217 appl_23 `pseq` applyWrapper appl_14 [appl_23]))) let !appl_24 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_25 = ApplC (Func "lambda" (Context (\(!kl_E) -> do return (Core.Types.Atom (Core.Types.UnboundSym "shen.nextline"))))) !appl_26 <- appl_24 `pseq` (kl_V2217 `pseq` (appl_25 `pseq` kl_compile appl_24 kl_V2217 appl_25)) appl_26 `pseq` applyWrapper appl_13 [appl_26] Atom (B (False)) -> do do !appl_27 <- kl_V2218 `pseq` kl_read_char_code kl_V2218 let !appl_28 = Atom Nil !appl_29 <- kl_V2216 `pseq` (appl_28 `pseq` klCons kl_V2216 appl_28) !appl_30 <- kl_V2217 `pseq` (appl_29 `pseq` kl_append kl_V2217 appl_29) appl_27 `pseq` (appl_30 `pseq` (kl_V2218 `pseq` kl_shen_lineread_loop appl_27 appl_30 kl_V2218)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" in case kl_V2216 of kl_V2216@(Atom (N (KI (-1)))) -> pat_cond_0 _ -> pat_cond_4 kl_shen_record_it :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_record_it (!kl_V2220) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_TrimLeft) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_TrimRight) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Trimmed) -> do kl_Trimmed `pseq` kl_shen_record_it_h kl_Trimmed))) !appl_3 <- kl_TrimRight `pseq` kl_reverse kl_TrimRight appl_3 `pseq` applyWrapper appl_2 [appl_3]))) !appl_4 <- kl_TrimLeft `pseq` kl_reverse kl_TrimLeft !appl_5 <- appl_4 `pseq` kl_shen_trim_whitespace appl_4 appl_5 `pseq` applyWrapper appl_1 [appl_5]))) !appl_6 <- kl_V2220 `pseq` kl_shen_trim_whitespace kl_V2220 appl_6 `pseq` applyWrapper appl_0 [appl_6] kl_shen_trim_whitespace :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_trim_whitespace (!kl_V2222) = do !kl_if_0 <- let pat_cond_1 kl_V2222 kl_V2222h kl_V2222t = do let !appl_2 = Atom Nil !appl_3 <- appl_2 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 32))) appl_2 !appl_4 <- appl_3 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 13))) appl_3 !appl_5 <- appl_4 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_4 !appl_6 <- appl_5 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 9))) appl_5 !kl_if_7 <- kl_V2222h `pseq` (appl_6 `pseq` kl_elementP kl_V2222h appl_6) case kl_if_7 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_8 = do do return (Atom (B False)) in case kl_V2222 of !(kl_V2222@(Cons (!kl_V2222h) (!kl_V2222t))) -> pat_cond_1 kl_V2222 kl_V2222h kl_V2222t _ -> pat_cond_8 case kl_if_0 of Atom (B (True)) -> do !appl_9 <- kl_V2222 `pseq` tl kl_V2222 appl_9 `pseq` kl_shen_trim_whitespace appl_9 Atom (B (False)) -> do do return kl_V2222 _ -> throwError "if: expected boolean" kl_shen_record_it_h :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_record_it_h (!kl_V2224) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` nToString kl_X))) !appl_1 <- appl_0 `pseq` (kl_V2224 `pseq` kl_map appl_0 kl_V2224) !appl_2 <- appl_1 `pseq` kl_shen_cn_all appl_1 !appl_3 <- appl_2 `pseq` klSet (Core.Types.Atom (Core.Types.UnboundSym "shen.*it*")) appl_2 appl_3 `pseq` (kl_V2224 `pseq` kl_do appl_3 kl_V2224) kl_shen_cn_all :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_cn_all (!kl_V2226) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2226 `pseq` eq appl_0 kl_V2226) case kl_if_1 of Atom (B (True)) -> do return (Core.Types.Atom (Core.Types.Str "")) Atom (B (False)) -> do let pat_cond_2 kl_V2226 kl_V2226h kl_V2226t = do !appl_3 <- kl_V2226t `pseq` kl_shen_cn_all kl_V2226t kl_V2226h `pseq` (appl_3 `pseq` cn kl_V2226h appl_3) pat_cond_4 = do do let !aw_5 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_5 [ApplC (wrapNamed "shen.cn-all" kl_shen_cn_all)] in case kl_V2226 of !(kl_V2226@(Cons (!kl_V2226h) (!kl_V2226t))) -> pat_cond_2 kl_V2226 kl_V2226h kl_V2226t _ -> pat_cond_4 _ -> throwError "if: expected boolean" kl_read_file :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_file (!kl_V2228) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Charlist) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_read_error kl_X))) appl_1 `pseq` (kl_Charlist `pseq` (appl_2 `pseq` kl_compile appl_1 kl_Charlist appl_2))))) !appl_3 <- kl_V2228 `pseq` kl_read_file_as_charlist kl_V2228 appl_3 `pseq` applyWrapper appl_0 [appl_3] kl_read_from_string :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_read_from_string (!kl_V2230) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Ns) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_LBst_inputRB kl_X))) let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` kl_shen_read_error kl_X))) appl_1 `pseq` (kl_Ns `pseq` (appl_2 `pseq` kl_compile appl_1 kl_Ns appl_2))))) let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_X) -> do kl_X `pseq` stringToN kl_X))) !appl_4 <- kl_V2230 `pseq` kl_explode kl_V2230 !appl_5 <- appl_3 `pseq` (appl_4 `pseq` kl_map appl_3 appl_4) appl_5 `pseq` applyWrapper appl_0 [appl_5] kl_shen_read_error :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_read_error (!kl_V2238) = do !kl_if_0 <- let pat_cond_1 kl_V2238 kl_V2238h kl_V2238t = do !kl_if_2 <- let pat_cond_3 kl_V2238h kl_V2238hh kl_V2238ht = do !kl_if_4 <- let pat_cond_5 kl_V2238t kl_V2238th kl_V2238tt = do let !appl_6 = Atom Nil !kl_if_7 <- appl_6 `pseq` (kl_V2238tt `pseq` eq appl_6 kl_V2238tt) case kl_if_7 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_8 = do do return (Atom (B False)) in case kl_V2238t of !(kl_V2238t@(Cons (!kl_V2238th) (!kl_V2238tt))) -> pat_cond_5 kl_V2238t kl_V2238th kl_V2238tt _ -> pat_cond_8 case kl_if_4 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_9 = do do return (Atom (B False)) in case kl_V2238h of !(kl_V2238h@(Cons (!kl_V2238hh) (!kl_V2238ht))) -> pat_cond_3 kl_V2238h kl_V2238hh kl_V2238ht _ -> pat_cond_9 case kl_if_2 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_10 = do do return (Atom (B False)) in case kl_V2238 of !(kl_V2238@(Cons (!kl_V2238h) (!kl_V2238t))) -> pat_cond_1 kl_V2238 kl_V2238h kl_V2238t _ -> pat_cond_10 case kl_if_0 of Atom (B (True)) -> do !appl_11 <- kl_V2238 `pseq` hd kl_V2238 !appl_12 <- appl_11 `pseq` kl_shen_compress_50 (Core.Types.Atom (Core.Types.N (Core.Types.KI 50))) appl_11 let !aw_13 = Core.Types.Atom (Core.Types.UnboundSym "shen.app") !appl_14 <- appl_12 `pseq` applyWrapper aw_13 [appl_12, Core.Types.Atom (Core.Types.Str "\n"), Core.Types.Atom (Core.Types.UnboundSym "shen.a")] !appl_15 <- appl_14 `pseq` cn (Core.Types.Atom (Core.Types.Str "read error here:\n\n ")) appl_14 appl_15 `pseq` simpleError appl_15 Atom (B (False)) -> do do simpleError (Core.Types.Atom (Core.Types.Str "read error\n")) _ -> throwError "if: expected boolean" kl_shen_compress_50 :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_compress_50 (!kl_V2245) (!kl_V2246) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2246 `pseq` eq appl_0 kl_V2246) case kl_if_1 of Atom (B (True)) -> do return (Core.Types.Atom (Core.Types.Str "")) Atom (B (False)) -> do let pat_cond_2 = do return (Core.Types.Atom (Core.Types.Str "")) pat_cond_3 = do let pat_cond_4 kl_V2246 kl_V2246h kl_V2246t = do !appl_5 <- kl_V2246h `pseq` nToString kl_V2246h !appl_6 <- kl_V2245 `pseq` Primitives.subtract kl_V2245 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_7 <- appl_6 `pseq` (kl_V2246t `pseq` kl_shen_compress_50 appl_6 kl_V2246t) appl_5 `pseq` (appl_7 `pseq` cn appl_5 appl_7) pat_cond_8 = do do let !aw_9 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_9 [ApplC (wrapNamed "shen.compress-50" kl_shen_compress_50)] in case kl_V2246 of !(kl_V2246@(Cons (!kl_V2246h) (!kl_V2246t))) -> pat_cond_4 kl_V2246 kl_V2246h kl_V2246t _ -> pat_cond_8 in case kl_V2245 of kl_V2245@(Atom (N (KI 0))) -> pat_cond_2 _ -> pat_cond_3 _ -> throwError "if: expected boolean" kl_shen_LBst_inputRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBst_inputRB (!kl_V2248) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_4 <- kl_fail !kl_if_5 <- kl_YaccParse `pseq` (appl_4 `pseq` eq kl_YaccParse appl_4) case kl_if_5 of Atom (B (True)) -> do let !appl_6 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_7 <- kl_fail !kl_if_8 <- kl_YaccParse `pseq` (appl_7 `pseq` eq kl_YaccParse appl_7) case kl_if_8 of Atom (B (True)) -> do let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_10 <- kl_fail !kl_if_11 <- kl_YaccParse `pseq` (appl_10 `pseq` eq kl_YaccParse appl_10) case kl_if_11 of Atom (B (True)) -> do let !appl_12 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_13 <- kl_fail !kl_if_14 <- kl_YaccParse `pseq` (appl_13 `pseq` eq kl_YaccParse appl_13) case kl_if_14 of Atom (B (True)) -> do let !appl_15 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_16 <- kl_fail !kl_if_17 <- kl_YaccParse `pseq` (appl_16 `pseq` eq kl_YaccParse appl_16) case kl_if_17 of Atom (B (True)) -> do let !appl_18 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_19 <- kl_fail !kl_if_20 <- kl_YaccParse `pseq` (appl_19 `pseq` eq kl_YaccParse appl_19) case kl_if_20 of Atom (B (True)) -> do let !appl_21 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_22 <- kl_fail !kl_if_23 <- kl_YaccParse `pseq` (appl_22 `pseq` eq kl_YaccParse appl_22) case kl_if_23 of Atom (B (True)) -> do let !appl_24 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_25 <- kl_fail !kl_if_26 <- kl_YaccParse `pseq` (appl_25 `pseq` eq kl_YaccParse appl_25) case kl_if_26 of Atom (B (True)) -> do let !appl_27 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_28 <- kl_fail !kl_if_29 <- kl_YaccParse `pseq` (appl_28 `pseq` eq kl_YaccParse appl_28) case kl_if_29 of Atom (B (True)) -> do let !appl_30 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_31 <- kl_fail !kl_if_32 <- kl_YaccParse `pseq` (appl_31 `pseq` eq kl_YaccParse appl_31) case kl_if_32 of Atom (B (True)) -> do let !appl_33 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_34 <- kl_fail !kl_if_35 <- kl_YaccParse `pseq` (appl_34 `pseq` eq kl_YaccParse appl_34) case kl_if_35 of Atom (B (True)) -> do let !appl_36 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_37 <- kl_fail !kl_if_38 <- kl_YaccParse `pseq` (appl_37 `pseq` eq kl_YaccParse appl_37) case kl_if_38 of Atom (B (True)) -> do let !appl_39 = ApplC (Func "lambda" (Context (\(!kl_Parse_LBeRB) -> do !appl_40 <- kl_fail !appl_41 <- appl_40 `pseq` (kl_Parse_LBeRB `pseq` eq appl_40 kl_Parse_LBeRB) !kl_if_42 <- appl_41 `pseq` kl_not appl_41 case kl_if_42 of Atom (B (True)) -> do !appl_43 <- kl_Parse_LBeRB `pseq` hd kl_Parse_LBeRB let !appl_44 = Atom Nil appl_43 `pseq` (appl_44 `pseq` kl_shen_pair appl_43 appl_44) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_45 <- kl_V2248 `pseq` kl_LBeRB kl_V2248 appl_45 `pseq` applyWrapper appl_39 [appl_45] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_46 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBwhitespacesRB) -> do !appl_47 <- kl_fail !appl_48 <- appl_47 `pseq` (kl_Parse_shen_LBwhitespacesRB `pseq` eq appl_47 kl_Parse_shen_LBwhitespacesRB) !kl_if_49 <- appl_48 `pseq` kl_not appl_48 case kl_if_49 of Atom (B (True)) -> do let !appl_50 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_51 <- kl_fail !appl_52 <- appl_51 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_51 kl_Parse_shen_LBst_inputRB) !kl_if_53 <- appl_52 `pseq` kl_not appl_52 case kl_if_53 of Atom (B (True)) -> do !appl_54 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_55 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB appl_54 `pseq` (appl_55 `pseq` kl_shen_pair appl_54 appl_55) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_56 <- kl_Parse_shen_LBwhitespacesRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBwhitespacesRB appl_56 `pseq` applyWrapper appl_50 [appl_56] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_57 <- kl_V2248 `pseq` kl_shen_LBwhitespacesRB kl_V2248 !appl_58 <- appl_57 `pseq` applyWrapper appl_46 [appl_57] appl_58 `pseq` applyWrapper appl_36 [appl_58] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_59 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBatomRB) -> do !appl_60 <- kl_fail !appl_61 <- appl_60 `pseq` (kl_Parse_shen_LBatomRB `pseq` eq appl_60 kl_Parse_shen_LBatomRB) !kl_if_62 <- appl_61 `pseq` kl_not appl_61 case kl_if_62 of Atom (B (True)) -> do let !appl_63 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_64 <- kl_fail !appl_65 <- appl_64 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_64 kl_Parse_shen_LBst_inputRB) !kl_if_66 <- appl_65 `pseq` kl_not appl_65 case kl_if_66 of Atom (B (True)) -> do !appl_67 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_68 <- kl_Parse_shen_LBatomRB `pseq` kl_shen_hdtl kl_Parse_shen_LBatomRB let !aw_69 = Core.Types.Atom (Core.Types.UnboundSym "macroexpand") !appl_70 <- appl_68 `pseq` applyWrapper aw_69 [appl_68] !appl_71 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_72 <- appl_70 `pseq` (appl_71 `pseq` klCons appl_70 appl_71) appl_67 `pseq` (appl_72 `pseq` kl_shen_pair appl_67 appl_72) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_73 <- kl_Parse_shen_LBatomRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBatomRB appl_73 `pseq` applyWrapper appl_63 [appl_73] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_74 <- kl_V2248 `pseq` kl_shen_LBatomRB kl_V2248 !appl_75 <- appl_74 `pseq` applyWrapper appl_59 [appl_74] appl_75 `pseq` applyWrapper appl_33 [appl_75] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_76 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcommentRB) -> do !appl_77 <- kl_fail !appl_78 <- appl_77 `pseq` (kl_Parse_shen_LBcommentRB `pseq` eq appl_77 kl_Parse_shen_LBcommentRB) !kl_if_79 <- appl_78 `pseq` kl_not appl_78 case kl_if_79 of Atom (B (True)) -> do let !appl_80 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_81 <- kl_fail !appl_82 <- appl_81 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_81 kl_Parse_shen_LBst_inputRB) !kl_if_83 <- appl_82 `pseq` kl_not appl_82 case kl_if_83 of Atom (B (True)) -> do !appl_84 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_85 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB appl_84 `pseq` (appl_85 `pseq` kl_shen_pair appl_84 appl_85) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_86 <- kl_Parse_shen_LBcommentRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBcommentRB appl_86 `pseq` applyWrapper appl_80 [appl_86] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_87 <- kl_V2248 `pseq` kl_shen_LBcommentRB kl_V2248 !appl_88 <- appl_87 `pseq` applyWrapper appl_76 [appl_87] appl_88 `pseq` applyWrapper appl_30 [appl_88] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_89 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcommaRB) -> do !appl_90 <- kl_fail !appl_91 <- appl_90 `pseq` (kl_Parse_shen_LBcommaRB `pseq` eq appl_90 kl_Parse_shen_LBcommaRB) !kl_if_92 <- appl_91 `pseq` kl_not appl_91 case kl_if_92 of Atom (B (True)) -> do let !appl_93 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_94 <- kl_fail !appl_95 <- appl_94 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_94 kl_Parse_shen_LBst_inputRB) !kl_if_96 <- appl_95 `pseq` kl_not appl_95 case kl_if_96 of Atom (B (True)) -> do !appl_97 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_98 <- intern (Core.Types.Atom (Core.Types.Str ",")) !appl_99 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_100 <- appl_98 `pseq` (appl_99 `pseq` klCons appl_98 appl_99) appl_97 `pseq` (appl_100 `pseq` kl_shen_pair appl_97 appl_100) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_101 <- kl_Parse_shen_LBcommaRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBcommaRB appl_101 `pseq` applyWrapper appl_93 [appl_101] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_102 <- kl_V2248 `pseq` kl_shen_LBcommaRB kl_V2248 !appl_103 <- appl_102 `pseq` applyWrapper appl_89 [appl_102] appl_103 `pseq` applyWrapper appl_27 [appl_103] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_104 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcolonRB) -> do !appl_105 <- kl_fail !appl_106 <- appl_105 `pseq` (kl_Parse_shen_LBcolonRB `pseq` eq appl_105 kl_Parse_shen_LBcolonRB) !kl_if_107 <- appl_106 `pseq` kl_not appl_106 case kl_if_107 of Atom (B (True)) -> do let !appl_108 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_109 <- kl_fail !appl_110 <- appl_109 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_109 kl_Parse_shen_LBst_inputRB) !kl_if_111 <- appl_110 `pseq` kl_not appl_110 case kl_if_111 of Atom (B (True)) -> do !appl_112 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_113 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_114 <- appl_113 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym ":")) appl_113 appl_112 `pseq` (appl_114 `pseq` kl_shen_pair appl_112 appl_114) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_115 <- kl_Parse_shen_LBcolonRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBcolonRB appl_115 `pseq` applyWrapper appl_108 [appl_115] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_116 <- kl_V2248 `pseq` kl_shen_LBcolonRB kl_V2248 !appl_117 <- appl_116 `pseq` applyWrapper appl_104 [appl_116] appl_117 `pseq` applyWrapper appl_24 [appl_117] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_118 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcolonRB) -> do !appl_119 <- kl_fail !appl_120 <- appl_119 `pseq` (kl_Parse_shen_LBcolonRB `pseq` eq appl_119 kl_Parse_shen_LBcolonRB) !kl_if_121 <- appl_120 `pseq` kl_not appl_120 case kl_if_121 of Atom (B (True)) -> do let !appl_122 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBminusRB) -> do !appl_123 <- kl_fail !appl_124 <- appl_123 `pseq` (kl_Parse_shen_LBminusRB `pseq` eq appl_123 kl_Parse_shen_LBminusRB) !kl_if_125 <- appl_124 `pseq` kl_not appl_124 case kl_if_125 of Atom (B (True)) -> do let !appl_126 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_127 <- kl_fail !appl_128 <- appl_127 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_127 kl_Parse_shen_LBst_inputRB) !kl_if_129 <- appl_128 `pseq` kl_not appl_128 case kl_if_129 of Atom (B (True)) -> do !appl_130 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_131 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_132 <- appl_131 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym ":-")) appl_131 appl_130 `pseq` (appl_132 `pseq` kl_shen_pair appl_130 appl_132) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_133 <- kl_Parse_shen_LBminusRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBminusRB appl_133 `pseq` applyWrapper appl_126 [appl_133] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_134 <- kl_Parse_shen_LBcolonRB `pseq` kl_shen_LBminusRB kl_Parse_shen_LBcolonRB appl_134 `pseq` applyWrapper appl_122 [appl_134] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_135 <- kl_V2248 `pseq` kl_shen_LBcolonRB kl_V2248 !appl_136 <- appl_135 `pseq` applyWrapper appl_118 [appl_135] appl_136 `pseq` applyWrapper appl_21 [appl_136] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_137 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcolonRB) -> do !appl_138 <- kl_fail !appl_139 <- appl_138 `pseq` (kl_Parse_shen_LBcolonRB `pseq` eq appl_138 kl_Parse_shen_LBcolonRB) !kl_if_140 <- appl_139 `pseq` kl_not appl_139 case kl_if_140 of Atom (B (True)) -> do let !appl_141 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBequalRB) -> do !appl_142 <- kl_fail !appl_143 <- appl_142 `pseq` (kl_Parse_shen_LBequalRB `pseq` eq appl_142 kl_Parse_shen_LBequalRB) !kl_if_144 <- appl_143 `pseq` kl_not appl_143 case kl_if_144 of Atom (B (True)) -> do let !appl_145 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_146 <- kl_fail !appl_147 <- appl_146 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_146 kl_Parse_shen_LBst_inputRB) !kl_if_148 <- appl_147 `pseq` kl_not appl_147 case kl_if_148 of Atom (B (True)) -> do !appl_149 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_150 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_151 <- appl_150 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym ":=")) appl_150 appl_149 `pseq` (appl_151 `pseq` kl_shen_pair appl_149 appl_151) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_152 <- kl_Parse_shen_LBequalRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBequalRB appl_152 `pseq` applyWrapper appl_145 [appl_152] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_153 <- kl_Parse_shen_LBcolonRB `pseq` kl_shen_LBequalRB kl_Parse_shen_LBcolonRB appl_153 `pseq` applyWrapper appl_141 [appl_153] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_154 <- kl_V2248 `pseq` kl_shen_LBcolonRB kl_V2248 !appl_155 <- appl_154 `pseq` applyWrapper appl_137 [appl_154] appl_155 `pseq` applyWrapper appl_18 [appl_155] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_156 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBsemicolonRB) -> do !appl_157 <- kl_fail !appl_158 <- appl_157 `pseq` (kl_Parse_shen_LBsemicolonRB `pseq` eq appl_157 kl_Parse_shen_LBsemicolonRB) !kl_if_159 <- appl_158 `pseq` kl_not appl_158 case kl_if_159 of Atom (B (True)) -> do let !appl_160 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_161 <- kl_fail !appl_162 <- appl_161 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_161 kl_Parse_shen_LBst_inputRB) !kl_if_163 <- appl_162 `pseq` kl_not appl_162 case kl_if_163 of Atom (B (True)) -> do !appl_164 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_165 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_166 <- appl_165 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym ";")) appl_165 appl_164 `pseq` (appl_166 `pseq` kl_shen_pair appl_164 appl_166) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_167 <- kl_Parse_shen_LBsemicolonRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBsemicolonRB appl_167 `pseq` applyWrapper appl_160 [appl_167] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_168 <- kl_V2248 `pseq` kl_shen_LBsemicolonRB kl_V2248 !appl_169 <- appl_168 `pseq` applyWrapper appl_156 [appl_168] appl_169 `pseq` applyWrapper appl_15 [appl_169] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_170 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBbarRB) -> do !appl_171 <- kl_fail !appl_172 <- appl_171 `pseq` (kl_Parse_shen_LBbarRB `pseq` eq appl_171 kl_Parse_shen_LBbarRB) !kl_if_173 <- appl_172 `pseq` kl_not appl_172 case kl_if_173 of Atom (B (True)) -> do let !appl_174 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_175 <- kl_fail !appl_176 <- appl_175 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_175 kl_Parse_shen_LBst_inputRB) !kl_if_177 <- appl_176 `pseq` kl_not appl_176 case kl_if_177 of Atom (B (True)) -> do !appl_178 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_179 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_180 <- appl_179 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym "bar!")) appl_179 appl_178 `pseq` (appl_180 `pseq` kl_shen_pair appl_178 appl_180) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_181 <- kl_Parse_shen_LBbarRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBbarRB appl_181 `pseq` applyWrapper appl_174 [appl_181] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_182 <- kl_V2248 `pseq` kl_shen_LBbarRB kl_V2248 !appl_183 <- appl_182 `pseq` applyWrapper appl_170 [appl_182] appl_183 `pseq` applyWrapper appl_12 [appl_183] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_184 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBrcurlyRB) -> do !appl_185 <- kl_fail !appl_186 <- appl_185 `pseq` (kl_Parse_shen_LBrcurlyRB `pseq` eq appl_185 kl_Parse_shen_LBrcurlyRB) !kl_if_187 <- appl_186 `pseq` kl_not appl_186 case kl_if_187 of Atom (B (True)) -> do let !appl_188 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_189 <- kl_fail !appl_190 <- appl_189 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_189 kl_Parse_shen_LBst_inputRB) !kl_if_191 <- appl_190 `pseq` kl_not appl_190 case kl_if_191 of Atom (B (True)) -> do !appl_192 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_193 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_194 <- appl_193 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym "}")) appl_193 appl_192 `pseq` (appl_194 `pseq` kl_shen_pair appl_192 appl_194) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_195 <- kl_Parse_shen_LBrcurlyRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBrcurlyRB appl_195 `pseq` applyWrapper appl_188 [appl_195] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_196 <- kl_V2248 `pseq` kl_shen_LBrcurlyRB kl_V2248 !appl_197 <- appl_196 `pseq` applyWrapper appl_184 [appl_196] appl_197 `pseq` applyWrapper appl_9 [appl_197] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_198 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBlcurlyRB) -> do !appl_199 <- kl_fail !appl_200 <- appl_199 `pseq` (kl_Parse_shen_LBlcurlyRB `pseq` eq appl_199 kl_Parse_shen_LBlcurlyRB) !kl_if_201 <- appl_200 `pseq` kl_not appl_200 case kl_if_201 of Atom (B (True)) -> do let !appl_202 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_203 <- kl_fail !appl_204 <- appl_203 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_203 kl_Parse_shen_LBst_inputRB) !kl_if_205 <- appl_204 `pseq` kl_not appl_204 case kl_if_205 of Atom (B (True)) -> do !appl_206 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_207 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB !appl_208 <- appl_207 `pseq` klCons (Core.Types.Atom (Core.Types.UnboundSym "{")) appl_207 appl_206 `pseq` (appl_208 `pseq` kl_shen_pair appl_206 appl_208) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_209 <- kl_Parse_shen_LBlcurlyRB `pseq` kl_shen_LBst_inputRB kl_Parse_shen_LBlcurlyRB appl_209 `pseq` applyWrapper appl_202 [appl_209] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_210 <- kl_V2248 `pseq` kl_shen_LBlcurlyRB kl_V2248 !appl_211 <- appl_210 `pseq` applyWrapper appl_198 [appl_210] appl_211 `pseq` applyWrapper appl_6 [appl_211] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_212 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBlrbRB) -> do !appl_213 <- kl_fail !appl_214 <- appl_213 `pseq` (kl_Parse_shen_LBlrbRB `pseq` eq appl_213 kl_Parse_shen_LBlrbRB) !kl_if_215 <- appl_214 `pseq` kl_not appl_214 case kl_if_215 of Atom (B (True)) -> do let !appl_216 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_input1RB) -> do !appl_217 <- kl_fail !appl_218 <- appl_217 `pseq` (kl_Parse_shen_LBst_input1RB `pseq` eq appl_217 kl_Parse_shen_LBst_input1RB) !kl_if_219 <- appl_218 `pseq` kl_not appl_218 case kl_if_219 of Atom (B (True)) -> do let !appl_220 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBrrbRB) -> do !appl_221 <- kl_fail !appl_222 <- appl_221 `pseq` (kl_Parse_shen_LBrrbRB `pseq` eq appl_221 kl_Parse_shen_LBrrbRB) !kl_if_223 <- appl_222 `pseq` kl_not appl_222 case kl_if_223 of Atom (B (True)) -> do let !appl_224 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_input2RB) -> do !appl_225 <- kl_fail !appl_226 <- appl_225 `pseq` (kl_Parse_shen_LBst_input2RB `pseq` eq appl_225 kl_Parse_shen_LBst_input2RB) !kl_if_227 <- appl_226 `pseq` kl_not appl_226 case kl_if_227 of Atom (B (True)) -> do !appl_228 <- kl_Parse_shen_LBst_input2RB `pseq` hd kl_Parse_shen_LBst_input2RB !appl_229 <- kl_Parse_shen_LBst_input1RB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_input1RB let !aw_230 = Core.Types.Atom (Core.Types.UnboundSym "macroexpand") !appl_231 <- appl_229 `pseq` applyWrapper aw_230 [appl_229] !appl_232 <- kl_Parse_shen_LBst_input2RB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_input2RB !appl_233 <- appl_231 `pseq` (appl_232 `pseq` kl_shen_package_macro appl_231 appl_232) appl_228 `pseq` (appl_233 `pseq` kl_shen_pair appl_228 appl_233) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_234 <- kl_Parse_shen_LBrrbRB `pseq` kl_shen_LBst_input2RB kl_Parse_shen_LBrrbRB appl_234 `pseq` applyWrapper appl_224 [appl_234] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_235 <- kl_Parse_shen_LBst_input1RB `pseq` kl_shen_LBrrbRB kl_Parse_shen_LBst_input1RB appl_235 `pseq` applyWrapper appl_220 [appl_235] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_236 <- kl_Parse_shen_LBlrbRB `pseq` kl_shen_LBst_input1RB kl_Parse_shen_LBlrbRB appl_236 `pseq` applyWrapper appl_216 [appl_236] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_237 <- kl_V2248 `pseq` kl_shen_LBlrbRB kl_V2248 !appl_238 <- appl_237 `pseq` applyWrapper appl_212 [appl_237] appl_238 `pseq` applyWrapper appl_3 [appl_238] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_239 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBlsbRB) -> do !appl_240 <- kl_fail !appl_241 <- appl_240 `pseq` (kl_Parse_shen_LBlsbRB `pseq` eq appl_240 kl_Parse_shen_LBlsbRB) !kl_if_242 <- appl_241 `pseq` kl_not appl_241 case kl_if_242 of Atom (B (True)) -> do let !appl_243 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_input1RB) -> do !appl_244 <- kl_fail !appl_245 <- appl_244 `pseq` (kl_Parse_shen_LBst_input1RB `pseq` eq appl_244 kl_Parse_shen_LBst_input1RB) !kl_if_246 <- appl_245 `pseq` kl_not appl_245 case kl_if_246 of Atom (B (True)) -> do let !appl_247 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBrsbRB) -> do !appl_248 <- kl_fail !appl_249 <- appl_248 `pseq` (kl_Parse_shen_LBrsbRB `pseq` eq appl_248 kl_Parse_shen_LBrsbRB) !kl_if_250 <- appl_249 `pseq` kl_not appl_249 case kl_if_250 of Atom (B (True)) -> do let !appl_251 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_input2RB) -> do !appl_252 <- kl_fail !appl_253 <- appl_252 `pseq` (kl_Parse_shen_LBst_input2RB `pseq` eq appl_252 kl_Parse_shen_LBst_input2RB) !kl_if_254 <- appl_253 `pseq` kl_not appl_253 case kl_if_254 of Atom (B (True)) -> do !appl_255 <- kl_Parse_shen_LBst_input2RB `pseq` hd kl_Parse_shen_LBst_input2RB !appl_256 <- kl_Parse_shen_LBst_input1RB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_input1RB !appl_257 <- appl_256 `pseq` kl_shen_cons_form appl_256 let !aw_258 = Core.Types.Atom (Core.Types.UnboundSym "macroexpand") !appl_259 <- appl_257 `pseq` applyWrapper aw_258 [appl_257] !appl_260 <- kl_Parse_shen_LBst_input2RB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_input2RB !appl_261 <- appl_259 `pseq` (appl_260 `pseq` klCons appl_259 appl_260) appl_255 `pseq` (appl_261 `pseq` kl_shen_pair appl_255 appl_261) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_262 <- kl_Parse_shen_LBrsbRB `pseq` kl_shen_LBst_input2RB kl_Parse_shen_LBrsbRB appl_262 `pseq` applyWrapper appl_251 [appl_262] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_263 <- kl_Parse_shen_LBst_input1RB `pseq` kl_shen_LBrsbRB kl_Parse_shen_LBst_input1RB appl_263 `pseq` applyWrapper appl_247 [appl_263] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_264 <- kl_Parse_shen_LBlsbRB `pseq` kl_shen_LBst_input1RB kl_Parse_shen_LBlsbRB appl_264 `pseq` applyWrapper appl_243 [appl_264] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_265 <- kl_V2248 `pseq` kl_shen_LBlsbRB kl_V2248 !appl_266 <- appl_265 `pseq` applyWrapper appl_239 [appl_265] appl_266 `pseq` applyWrapper appl_0 [appl_266] kl_shen_LBlsbRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBlsbRB (!kl_V2250) = do !appl_0 <- kl_V2250 `pseq` hd kl_V2250 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2250 `pseq` hd kl_V2250 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 91))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2250 `pseq` hd kl_V2250 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2250 `pseq` kl_shen_hdtl kl_V2250 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBrsbRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBrsbRB (!kl_V2252) = do !appl_0 <- kl_V2252 `pseq` hd kl_V2252 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2252 `pseq` hd kl_V2252 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 93))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2252 `pseq` hd kl_V2252 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2252 `pseq` kl_shen_hdtl kl_V2252 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBlcurlyRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBlcurlyRB (!kl_V2254) = do !appl_0 <- kl_V2254 `pseq` hd kl_V2254 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2254 `pseq` hd kl_V2254 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 123))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2254 `pseq` hd kl_V2254 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2254 `pseq` kl_shen_hdtl kl_V2254 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBrcurlyRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBrcurlyRB (!kl_V2256) = do !appl_0 <- kl_V2256 `pseq` hd kl_V2256 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2256 `pseq` hd kl_V2256 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 125))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2256 `pseq` hd kl_V2256 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2256 `pseq` kl_shen_hdtl kl_V2256 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBbarRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBbarRB (!kl_V2258) = do !appl_0 <- kl_V2258 `pseq` hd kl_V2258 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2258 `pseq` hd kl_V2258 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 124))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2258 `pseq` hd kl_V2258 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2258 `pseq` kl_shen_hdtl kl_V2258 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBsemicolonRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBsemicolonRB (!kl_V2260) = do !appl_0 <- kl_V2260 `pseq` hd kl_V2260 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2260 `pseq` hd kl_V2260 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 59))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2260 `pseq` hd kl_V2260 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2260 `pseq` kl_shen_hdtl kl_V2260 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBcolonRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBcolonRB (!kl_V2262) = do !appl_0 <- kl_V2262 `pseq` hd kl_V2262 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2262 `pseq` hd kl_V2262 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 58))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2262 `pseq` hd kl_V2262 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2262 `pseq` kl_shen_hdtl kl_V2262 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBcommaRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBcommaRB (!kl_V2264) = do !appl_0 <- kl_V2264 `pseq` hd kl_V2264 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2264 `pseq` hd kl_V2264 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 44))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2264 `pseq` hd kl_V2264 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2264 `pseq` kl_shen_hdtl kl_V2264 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBequalRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBequalRB (!kl_V2266) = do !appl_0 <- kl_V2266 `pseq` hd kl_V2266 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2266 `pseq` hd kl_V2266 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 61))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2266 `pseq` hd kl_V2266 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2266 `pseq` kl_shen_hdtl kl_V2266 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBminusRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBminusRB (!kl_V2268) = do !appl_0 <- kl_V2268 `pseq` hd kl_V2268 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2268 `pseq` hd kl_V2268 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 45))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2268 `pseq` hd kl_V2268 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2268 `pseq` kl_shen_hdtl kl_V2268 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBlrbRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBlrbRB (!kl_V2270) = do !appl_0 <- kl_V2270 `pseq` hd kl_V2270 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2270 `pseq` hd kl_V2270 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 40))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2270 `pseq` hd kl_V2270 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2270 `pseq` kl_shen_hdtl kl_V2270 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBrrbRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBrrbRB (!kl_V2272) = do !appl_0 <- kl_V2272 `pseq` hd kl_V2272 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2272 `pseq` hd kl_V2272 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 41))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2272 `pseq` hd kl_V2272 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2272 `pseq` kl_shen_hdtl kl_V2272 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBatomRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBatomRB (!kl_V2274) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_4 <- kl_fail !kl_if_5 <- kl_YaccParse `pseq` (appl_4 `pseq` eq kl_YaccParse appl_4) case kl_if_5 of Atom (B (True)) -> do let !appl_6 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBsymRB) -> do !appl_7 <- kl_fail !appl_8 <- appl_7 `pseq` (kl_Parse_shen_LBsymRB `pseq` eq appl_7 kl_Parse_shen_LBsymRB) !kl_if_9 <- appl_8 `pseq` kl_not appl_8 case kl_if_9 of Atom (B (True)) -> do !appl_10 <- kl_Parse_shen_LBsymRB `pseq` hd kl_Parse_shen_LBsymRB !appl_11 <- kl_Parse_shen_LBsymRB `pseq` kl_shen_hdtl kl_Parse_shen_LBsymRB !kl_if_12 <- appl_11 `pseq` eq appl_11 (Core.Types.Atom (Core.Types.Str "<>")) !appl_13 <- case kl_if_12 of Atom (B (True)) -> do let !appl_14 = Atom Nil !appl_15 <- appl_14 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_14 appl_15 `pseq` klCons (ApplC (wrapNamed "vector" kl_vector)) appl_15 Atom (B (False)) -> do do !appl_16 <- kl_Parse_shen_LBsymRB `pseq` kl_shen_hdtl kl_Parse_shen_LBsymRB appl_16 `pseq` intern appl_16 _ -> throwError "if: expected boolean" appl_10 `pseq` (appl_13 `pseq` kl_shen_pair appl_10 appl_13) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_17 <- kl_V2274 `pseq` kl_shen_LBsymRB kl_V2274 appl_17 `pseq` applyWrapper appl_6 [appl_17] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_18 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBnumberRB) -> do !appl_19 <- kl_fail !appl_20 <- appl_19 `pseq` (kl_Parse_shen_LBnumberRB `pseq` eq appl_19 kl_Parse_shen_LBnumberRB) !kl_if_21 <- appl_20 `pseq` kl_not appl_20 case kl_if_21 of Atom (B (True)) -> do !appl_22 <- kl_Parse_shen_LBnumberRB `pseq` hd kl_Parse_shen_LBnumberRB !appl_23 <- kl_Parse_shen_LBnumberRB `pseq` kl_shen_hdtl kl_Parse_shen_LBnumberRB appl_22 `pseq` (appl_23 `pseq` kl_shen_pair appl_22 appl_23) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_24 <- kl_V2274 `pseq` kl_shen_LBnumberRB kl_V2274 !appl_25 <- appl_24 `pseq` applyWrapper appl_18 [appl_24] appl_25 `pseq` applyWrapper appl_3 [appl_25] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_26 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstrRB) -> do !appl_27 <- kl_fail !appl_28 <- appl_27 `pseq` (kl_Parse_shen_LBstrRB `pseq` eq appl_27 kl_Parse_shen_LBstrRB) !kl_if_29 <- appl_28 `pseq` kl_not appl_28 case kl_if_29 of Atom (B (True)) -> do !appl_30 <- kl_Parse_shen_LBstrRB `pseq` hd kl_Parse_shen_LBstrRB !appl_31 <- kl_Parse_shen_LBstrRB `pseq` kl_shen_hdtl kl_Parse_shen_LBstrRB !appl_32 <- appl_31 `pseq` kl_shen_control_chars appl_31 appl_30 `pseq` (appl_32 `pseq` kl_shen_pair appl_30 appl_32) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_33 <- kl_V2274 `pseq` kl_shen_LBstrRB kl_V2274 !appl_34 <- appl_33 `pseq` applyWrapper appl_26 [appl_33] appl_34 `pseq` applyWrapper appl_0 [appl_34] kl_shen_control_chars :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_control_chars (!kl_V2276) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2276 `pseq` eq appl_0 kl_V2276) case kl_if_1 of Atom (B (True)) -> do return (Core.Types.Atom (Core.Types.Str "")) Atom (B (False)) -> do let pat_cond_2 kl_V2276 kl_V2276t kl_V2276tt = do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_CodePoint) -> do let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_AfterCodePoint) -> do !appl_5 <- kl_CodePoint `pseq` kl_shen_decimalise kl_CodePoint !appl_6 <- appl_5 `pseq` nToString appl_5 !appl_7 <- kl_AfterCodePoint `pseq` kl_shen_control_chars kl_AfterCodePoint appl_6 `pseq` (appl_7 `pseq` kl_Ats appl_6 appl_7)))) !appl_8 <- kl_V2276tt `pseq` kl_shen_after_codepoint kl_V2276tt appl_8 `pseq` applyWrapper appl_4 [appl_8]))) !appl_9 <- kl_V2276tt `pseq` kl_shen_code_point kl_V2276tt appl_9 `pseq` applyWrapper appl_3 [appl_9] pat_cond_10 kl_V2276 kl_V2276h kl_V2276t = do !appl_11 <- kl_V2276t `pseq` kl_shen_control_chars kl_V2276t kl_V2276h `pseq` (appl_11 `pseq` kl_Ats kl_V2276h appl_11) pat_cond_12 = do do let !aw_13 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_13 [ApplC (wrapNamed "shen.control-chars" kl_shen_control_chars)] in case kl_V2276 of !(kl_V2276@(Cons (Atom (Str "c")) (!(kl_V2276t@(Cons (Atom (Str "#")) (!kl_V2276tt)))))) -> pat_cond_2 kl_V2276 kl_V2276t kl_V2276tt !(kl_V2276@(Cons (!kl_V2276h) (!kl_V2276t))) -> pat_cond_10 kl_V2276 kl_V2276h kl_V2276t _ -> pat_cond_12 _ -> throwError "if: expected boolean" kl_shen_code_point :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_code_point (!kl_V2280) = do let pat_cond_0 kl_V2280 kl_V2280t = do return (Core.Types.Atom (Core.Types.Str "")) pat_cond_1 = do !kl_if_2 <- let pat_cond_3 kl_V2280 kl_V2280h kl_V2280t = do let !appl_4 = Atom Nil !appl_5 <- appl_4 `pseq` klCons (Core.Types.Atom (Core.Types.Str "0")) appl_4 !appl_6 <- appl_5 `pseq` klCons (Core.Types.Atom (Core.Types.Str "9")) appl_5 !appl_7 <- appl_6 `pseq` klCons (Core.Types.Atom (Core.Types.Str "8")) appl_6 !appl_8 <- appl_7 `pseq` klCons (Core.Types.Atom (Core.Types.Str "7")) appl_7 !appl_9 <- appl_8 `pseq` klCons (Core.Types.Atom (Core.Types.Str "6")) appl_8 !appl_10 <- appl_9 `pseq` klCons (Core.Types.Atom (Core.Types.Str "5")) appl_9 !appl_11 <- appl_10 `pseq` klCons (Core.Types.Atom (Core.Types.Str "4")) appl_10 !appl_12 <- appl_11 `pseq` klCons (Core.Types.Atom (Core.Types.Str "3")) appl_11 !appl_13 <- appl_12 `pseq` klCons (Core.Types.Atom (Core.Types.Str "2")) appl_12 !appl_14 <- appl_13 `pseq` klCons (Core.Types.Atom (Core.Types.Str "1")) appl_13 !appl_15 <- appl_14 `pseq` klCons (Core.Types.Atom (Core.Types.Str "0")) appl_14 !kl_if_16 <- kl_V2280h `pseq` (appl_15 `pseq` kl_elementP kl_V2280h appl_15) case kl_if_16 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_17 = do do return (Atom (B False)) in case kl_V2280 of !(kl_V2280@(Cons (!kl_V2280h) (!kl_V2280t))) -> pat_cond_3 kl_V2280 kl_V2280h kl_V2280t _ -> pat_cond_17 case kl_if_2 of Atom (B (True)) -> do !appl_18 <- kl_V2280 `pseq` hd kl_V2280 !appl_19 <- kl_V2280 `pseq` tl kl_V2280 !appl_20 <- appl_19 `pseq` kl_shen_code_point appl_19 appl_18 `pseq` (appl_20 `pseq` klCons appl_18 appl_20) Atom (B (False)) -> do do let !aw_21 = Core.Types.Atom (Core.Types.UnboundSym "shen.app") !appl_22 <- kl_V2280 `pseq` applyWrapper aw_21 [kl_V2280, Core.Types.Atom (Core.Types.Str "\n"), Core.Types.Atom (Core.Types.UnboundSym "shen.a")] !appl_23 <- appl_22 `pseq` cn (Core.Types.Atom (Core.Types.Str "code point parse error ")) appl_22 appl_23 `pseq` simpleError appl_23 _ -> throwError "if: expected boolean" in case kl_V2280 of !(kl_V2280@(Cons (Atom (Str ";")) (!kl_V2280t))) -> pat_cond_0 kl_V2280 kl_V2280t _ -> pat_cond_1 kl_shen_after_codepoint :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_after_codepoint (!kl_V2286) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2286 `pseq` eq appl_0 kl_V2286) case kl_if_1 of Atom (B (True)) -> do return (Atom Nil) Atom (B (False)) -> do let pat_cond_2 kl_V2286 kl_V2286t = do return kl_V2286t pat_cond_3 kl_V2286 kl_V2286h kl_V2286t = do kl_V2286t `pseq` kl_shen_after_codepoint kl_V2286t pat_cond_4 = do do let !aw_5 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_5 [ApplC (wrapNamed "shen.after-codepoint" kl_shen_after_codepoint)] in case kl_V2286 of !(kl_V2286@(Cons (Atom (Str ";")) (!kl_V2286t))) -> pat_cond_2 kl_V2286 kl_V2286t !(kl_V2286@(Cons (!kl_V2286h) (!kl_V2286t))) -> pat_cond_3 kl_V2286 kl_V2286h kl_V2286t _ -> pat_cond_4 _ -> throwError "if: expected boolean" kl_shen_decimalise :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_decimalise (!kl_V2288) = do !appl_0 <- kl_V2288 `pseq` kl_shen_digits_RBintegers kl_V2288 !appl_1 <- appl_0 `pseq` kl_reverse appl_0 appl_1 `pseq` kl_shen_pre appl_1 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) kl_shen_digits_RBintegers :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_digits_RBintegers (!kl_V2294) = do let pat_cond_0 kl_V2294 kl_V2294t = do !appl_1 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_1 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_1 pat_cond_2 kl_V2294 kl_V2294t = do !appl_3 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_3 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) appl_3 pat_cond_4 kl_V2294 kl_V2294t = do !appl_5 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_5 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 2))) appl_5 pat_cond_6 kl_V2294 kl_V2294t = do !appl_7 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_7 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 3))) appl_7 pat_cond_8 kl_V2294 kl_V2294t = do !appl_9 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_9 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 4))) appl_9 pat_cond_10 kl_V2294 kl_V2294t = do !appl_11 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_11 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 5))) appl_11 pat_cond_12 kl_V2294 kl_V2294t = do !appl_13 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_13 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 6))) appl_13 pat_cond_14 kl_V2294 kl_V2294t = do !appl_15 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_15 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 7))) appl_15 pat_cond_16 kl_V2294 kl_V2294t = do !appl_17 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_17 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 8))) appl_17 pat_cond_18 kl_V2294 kl_V2294t = do !appl_19 <- kl_V2294t `pseq` kl_shen_digits_RBintegers kl_V2294t appl_19 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 9))) appl_19 pat_cond_20 = do do return (Atom Nil) in case kl_V2294 of !(kl_V2294@(Cons (Atom (Str "0")) (!kl_V2294t))) -> pat_cond_0 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "1")) (!kl_V2294t))) -> pat_cond_2 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "2")) (!kl_V2294t))) -> pat_cond_4 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "3")) (!kl_V2294t))) -> pat_cond_6 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "4")) (!kl_V2294t))) -> pat_cond_8 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "5")) (!kl_V2294t))) -> pat_cond_10 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "6")) (!kl_V2294t))) -> pat_cond_12 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "7")) (!kl_V2294t))) -> pat_cond_14 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "8")) (!kl_V2294t))) -> pat_cond_16 kl_V2294 kl_V2294t !(kl_V2294@(Cons (Atom (Str "9")) (!kl_V2294t))) -> pat_cond_18 kl_V2294 kl_V2294t _ -> pat_cond_20 kl_shen_LBsymRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBsymRB (!kl_V2296) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBalphaRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBalphaRB `pseq` eq appl_1 kl_Parse_shen_LBalphaRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBalphanumsRB) -> do !appl_5 <- kl_fail !appl_6 <- appl_5 `pseq` (kl_Parse_shen_LBalphanumsRB `pseq` eq appl_5 kl_Parse_shen_LBalphanumsRB) !kl_if_7 <- appl_6 `pseq` kl_not appl_6 case kl_if_7 of Atom (B (True)) -> do !appl_8 <- kl_Parse_shen_LBalphanumsRB `pseq` hd kl_Parse_shen_LBalphanumsRB !appl_9 <- kl_Parse_shen_LBalphaRB `pseq` kl_shen_hdtl kl_Parse_shen_LBalphaRB !appl_10 <- kl_Parse_shen_LBalphanumsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBalphanumsRB !appl_11 <- appl_9 `pseq` (appl_10 `pseq` kl_Ats appl_9 appl_10) appl_8 `pseq` (appl_11 `pseq` kl_shen_pair appl_8 appl_11) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_12 <- kl_Parse_shen_LBalphaRB `pseq` kl_shen_LBalphanumsRB kl_Parse_shen_LBalphaRB appl_12 `pseq` applyWrapper appl_4 [appl_12] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_13 <- kl_V2296 `pseq` kl_shen_LBalphaRB kl_V2296 appl_13 `pseq` applyWrapper appl_0 [appl_13] kl_shen_LBalphanumsRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBalphanumsRB (!kl_V2298) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_LBeRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_LBeRB `pseq` eq appl_4 kl_Parse_LBeRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_LBeRB `pseq` hd kl_Parse_LBeRB appl_7 `pseq` kl_shen_pair appl_7 (Core.Types.Atom (Core.Types.Str "")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_8 <- kl_V2298 `pseq` kl_LBeRB kl_V2298 appl_8 `pseq` applyWrapper appl_3 [appl_8] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBalphanumRB) -> do !appl_10 <- kl_fail !appl_11 <- appl_10 `pseq` (kl_Parse_shen_LBalphanumRB `pseq` eq appl_10 kl_Parse_shen_LBalphanumRB) !kl_if_12 <- appl_11 `pseq` kl_not appl_11 case kl_if_12 of Atom (B (True)) -> do let !appl_13 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBalphanumsRB) -> do !appl_14 <- kl_fail !appl_15 <- appl_14 `pseq` (kl_Parse_shen_LBalphanumsRB `pseq` eq appl_14 kl_Parse_shen_LBalphanumsRB) !kl_if_16 <- appl_15 `pseq` kl_not appl_15 case kl_if_16 of Atom (B (True)) -> do !appl_17 <- kl_Parse_shen_LBalphanumsRB `pseq` hd kl_Parse_shen_LBalphanumsRB !appl_18 <- kl_Parse_shen_LBalphanumRB `pseq` kl_shen_hdtl kl_Parse_shen_LBalphanumRB !appl_19 <- kl_Parse_shen_LBalphanumsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBalphanumsRB !appl_20 <- appl_18 `pseq` (appl_19 `pseq` kl_Ats appl_18 appl_19) appl_17 `pseq` (appl_20 `pseq` kl_shen_pair appl_17 appl_20) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_21 <- kl_Parse_shen_LBalphanumRB `pseq` kl_shen_LBalphanumsRB kl_Parse_shen_LBalphanumRB appl_21 `pseq` applyWrapper appl_13 [appl_21] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_22 <- kl_V2298 `pseq` kl_shen_LBalphanumRB kl_V2298 !appl_23 <- appl_22 `pseq` applyWrapper appl_9 [appl_22] appl_23 `pseq` applyWrapper appl_0 [appl_23] kl_shen_LBalphanumRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBalphanumRB (!kl_V2300) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBnumRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_shen_LBnumRB `pseq` eq appl_4 kl_Parse_shen_LBnumRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_shen_LBnumRB `pseq` hd kl_Parse_shen_LBnumRB !appl_8 <- kl_Parse_shen_LBnumRB `pseq` kl_shen_hdtl kl_Parse_shen_LBnumRB appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_9 <- kl_V2300 `pseq` kl_shen_LBnumRB kl_V2300 appl_9 `pseq` applyWrapper appl_3 [appl_9] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_10 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBalphaRB) -> do !appl_11 <- kl_fail !appl_12 <- appl_11 `pseq` (kl_Parse_shen_LBalphaRB `pseq` eq appl_11 kl_Parse_shen_LBalphaRB) !kl_if_13 <- appl_12 `pseq` kl_not appl_12 case kl_if_13 of Atom (B (True)) -> do !appl_14 <- kl_Parse_shen_LBalphaRB `pseq` hd kl_Parse_shen_LBalphaRB !appl_15 <- kl_Parse_shen_LBalphaRB `pseq` kl_shen_hdtl kl_Parse_shen_LBalphaRB appl_14 `pseq` (appl_15 `pseq` kl_shen_pair appl_14 appl_15) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_16 <- kl_V2300 `pseq` kl_shen_LBalphaRB kl_V2300 !appl_17 <- appl_16 `pseq` applyWrapper appl_10 [appl_16] appl_17 `pseq` applyWrapper appl_0 [appl_17] kl_shen_LBnumRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBnumRB (!kl_V2302) = do !appl_0 <- kl_V2302 `pseq` hd kl_V2302 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do !kl_if_3 <- kl_Parse_Char `pseq` kl_shen_numbyteP kl_Parse_Char case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_V2302 `pseq` hd kl_V2302 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2302 `pseq` kl_shen_hdtl kl_V2302 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 !appl_9 <- kl_Parse_Char `pseq` nToString kl_Parse_Char appl_8 `pseq` (appl_9 `pseq` kl_shen_pair appl_8 appl_9) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_10 <- kl_V2302 `pseq` hd kl_V2302 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_numbyteP :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_numbyteP (!kl_V2308) = do let pat_cond_0 = do return (Atom (B True)) pat_cond_1 = do return (Atom (B True)) pat_cond_2 = do return (Atom (B True)) pat_cond_3 = do return (Atom (B True)) pat_cond_4 = do return (Atom (B True)) pat_cond_5 = do return (Atom (B True)) pat_cond_6 = do return (Atom (B True)) pat_cond_7 = do return (Atom (B True)) pat_cond_8 = do return (Atom (B True)) pat_cond_9 = do return (Atom (B True)) pat_cond_10 = do do return (Atom (B False)) in case kl_V2308 of kl_V2308@(Atom (N (KI 48))) -> pat_cond_0 kl_V2308@(Atom (N (KI 49))) -> pat_cond_1 kl_V2308@(Atom (N (KI 50))) -> pat_cond_2 kl_V2308@(Atom (N (KI 51))) -> pat_cond_3 kl_V2308@(Atom (N (KI 52))) -> pat_cond_4 kl_V2308@(Atom (N (KI 53))) -> pat_cond_5 kl_V2308@(Atom (N (KI 54))) -> pat_cond_6 kl_V2308@(Atom (N (KI 55))) -> pat_cond_7 kl_V2308@(Atom (N (KI 56))) -> pat_cond_8 kl_V2308@(Atom (N (KI 57))) -> pat_cond_9 _ -> pat_cond_10 kl_shen_LBalphaRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBalphaRB (!kl_V2310) = do !appl_0 <- kl_V2310 `pseq` hd kl_V2310 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do !kl_if_3 <- kl_Parse_Char `pseq` kl_shen_symbol_codeP kl_Parse_Char case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_V2310 `pseq` hd kl_V2310 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2310 `pseq` kl_shen_hdtl kl_V2310 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 !appl_9 <- kl_Parse_Char `pseq` nToString kl_Parse_Char appl_8 `pseq` (appl_9 `pseq` kl_shen_pair appl_8 appl_9) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_10 <- kl_V2310 `pseq` hd kl_V2310 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_symbol_codeP :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_symbol_codeP (!kl_V2312) = do let pat_cond_0 = do return (Atom (B True)) pat_cond_1 = do do !kl_if_2 <- kl_V2312 `pseq` greaterThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 94))) !kl_if_3 <- case kl_if_2 of Atom (B (True)) -> do !kl_if_4 <- kl_V2312 `pseq` lessThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 123))) case kl_if_4 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" !kl_if_5 <- case kl_if_3 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_6 <- kl_V2312 `pseq` greaterThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 59))) !kl_if_7 <- case kl_if_6 of Atom (B (True)) -> do !kl_if_8 <- kl_V2312 `pseq` lessThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 91))) case kl_if_8 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" !kl_if_9 <- case kl_if_7 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_10 <- kl_V2312 `pseq` greaterThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 41))) !kl_if_11 <- case kl_if_10 of Atom (B (True)) -> do !kl_if_12 <- kl_V2312 `pseq` lessThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 58))) !kl_if_13 <- case kl_if_12 of Atom (B (True)) -> do !appl_14 <- kl_V2312 `pseq` eq kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 44))) !kl_if_15 <- appl_14 `pseq` kl_not appl_14 case kl_if_15 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_13 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" !kl_if_16 <- case kl_if_11 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_17 <- kl_V2312 `pseq` greaterThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 34))) !kl_if_18 <- case kl_if_17 of Atom (B (True)) -> do !kl_if_19 <- kl_V2312 `pseq` lessThan kl_V2312 (Core.Types.Atom (Core.Types.N (Core.Types.KI 40))) case kl_if_19 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" !kl_if_20 <- case kl_if_18 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do let pat_cond_21 = do return (Atom (B True)) pat_cond_22 = do do return (Atom (B False)) in case kl_V2312 of kl_V2312@(Atom (N (KI 33))) -> pat_cond_21 _ -> pat_cond_22 _ -> throwError "if: expected boolean" case kl_if_20 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_16 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_9 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" in case kl_V2312 of kl_V2312@(Atom (N (KI 126))) -> pat_cond_0 _ -> pat_cond_1 kl_shen_LBstrRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBstrRB (!kl_V2314) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdbqRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBdbqRB `pseq` eq appl_1 kl_Parse_shen_LBdbqRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstrcontentsRB) -> do !appl_5 <- kl_fail !appl_6 <- appl_5 `pseq` (kl_Parse_shen_LBstrcontentsRB `pseq` eq appl_5 kl_Parse_shen_LBstrcontentsRB) !kl_if_7 <- appl_6 `pseq` kl_not appl_6 case kl_if_7 of Atom (B (True)) -> do let !appl_8 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdbqRB) -> do !appl_9 <- kl_fail !appl_10 <- appl_9 `pseq` (kl_Parse_shen_LBdbqRB `pseq` eq appl_9 kl_Parse_shen_LBdbqRB) !kl_if_11 <- appl_10 `pseq` kl_not appl_10 case kl_if_11 of Atom (B (True)) -> do !appl_12 <- kl_Parse_shen_LBdbqRB `pseq` hd kl_Parse_shen_LBdbqRB !appl_13 <- kl_Parse_shen_LBstrcontentsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBstrcontentsRB appl_12 `pseq` (appl_13 `pseq` kl_shen_pair appl_12 appl_13) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_14 <- kl_Parse_shen_LBstrcontentsRB `pseq` kl_shen_LBdbqRB kl_Parse_shen_LBstrcontentsRB appl_14 `pseq` applyWrapper appl_8 [appl_14] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_15 <- kl_Parse_shen_LBdbqRB `pseq` kl_shen_LBstrcontentsRB kl_Parse_shen_LBdbqRB appl_15 `pseq` applyWrapper appl_4 [appl_15] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_16 <- kl_V2314 `pseq` kl_shen_LBdbqRB kl_V2314 appl_16 `pseq` applyWrapper appl_0 [appl_16] kl_shen_LBdbqRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBdbqRB (!kl_V2316) = do !appl_0 <- kl_V2316 `pseq` hd kl_V2316 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do let pat_cond_3 = do !appl_4 <- kl_V2316 `pseq` hd kl_V2316 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2316 `pseq` kl_shen_hdtl kl_V2316 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 appl_8 `pseq` (kl_Parse_Char `pseq` kl_shen_pair appl_8 kl_Parse_Char) pat_cond_9 = do do kl_fail in case kl_Parse_Char of kl_Parse_Char@(Atom (N (KI 34))) -> pat_cond_3 _ -> pat_cond_9))) !appl_10 <- kl_V2316 `pseq` hd kl_V2316 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBstrcontentsRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBstrcontentsRB (!kl_V2318) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_LBeRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_LBeRB `pseq` eq appl_4 kl_Parse_LBeRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_LBeRB `pseq` hd kl_Parse_LBeRB let !appl_8 = Atom Nil appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_9 <- kl_V2318 `pseq` kl_LBeRB kl_V2318 appl_9 `pseq` applyWrapper appl_3 [appl_9] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_10 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstrcRB) -> do !appl_11 <- kl_fail !appl_12 <- appl_11 `pseq` (kl_Parse_shen_LBstrcRB `pseq` eq appl_11 kl_Parse_shen_LBstrcRB) !kl_if_13 <- appl_12 `pseq` kl_not appl_12 case kl_if_13 of Atom (B (True)) -> do let !appl_14 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstrcontentsRB) -> do !appl_15 <- kl_fail !appl_16 <- appl_15 `pseq` (kl_Parse_shen_LBstrcontentsRB `pseq` eq appl_15 kl_Parse_shen_LBstrcontentsRB) !kl_if_17 <- appl_16 `pseq` kl_not appl_16 case kl_if_17 of Atom (B (True)) -> do !appl_18 <- kl_Parse_shen_LBstrcontentsRB `pseq` hd kl_Parse_shen_LBstrcontentsRB !appl_19 <- kl_Parse_shen_LBstrcRB `pseq` kl_shen_hdtl kl_Parse_shen_LBstrcRB !appl_20 <- kl_Parse_shen_LBstrcontentsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBstrcontentsRB !appl_21 <- appl_19 `pseq` (appl_20 `pseq` klCons appl_19 appl_20) appl_18 `pseq` (appl_21 `pseq` kl_shen_pair appl_18 appl_21) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_22 <- kl_Parse_shen_LBstrcRB `pseq` kl_shen_LBstrcontentsRB kl_Parse_shen_LBstrcRB appl_22 `pseq` applyWrapper appl_14 [appl_22] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_23 <- kl_V2318 `pseq` kl_shen_LBstrcRB kl_V2318 !appl_24 <- appl_23 `pseq` applyWrapper appl_10 [appl_23] appl_24 `pseq` applyWrapper appl_0 [appl_24] kl_shen_LBbyteRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBbyteRB (!kl_V2320) = do !appl_0 <- kl_V2320 `pseq` hd kl_V2320 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do !appl_3 <- kl_V2320 `pseq` hd kl_V2320 !appl_4 <- appl_3 `pseq` tl appl_3 !appl_5 <- kl_V2320 `pseq` kl_shen_hdtl kl_V2320 !appl_6 <- appl_4 `pseq` (appl_5 `pseq` kl_shen_pair appl_4 appl_5) !appl_7 <- appl_6 `pseq` hd appl_6 !appl_8 <- kl_Parse_Char `pseq` nToString kl_Parse_Char appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8)))) !appl_9 <- kl_V2320 `pseq` hd kl_V2320 !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` applyWrapper appl_2 [appl_10] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBstrcRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBstrcRB (!kl_V2322) = do !appl_0 <- kl_V2322 `pseq` hd kl_V2322 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do !appl_3 <- kl_Parse_Char `pseq` eq kl_Parse_Char (Core.Types.Atom (Core.Types.N (Core.Types.KI 34))) !kl_if_4 <- appl_3 `pseq` kl_not appl_3 case kl_if_4 of Atom (B (True)) -> do !appl_5 <- kl_V2322 `pseq` hd kl_V2322 !appl_6 <- appl_5 `pseq` tl appl_5 !appl_7 <- kl_V2322 `pseq` kl_shen_hdtl kl_V2322 !appl_8 <- appl_6 `pseq` (appl_7 `pseq` kl_shen_pair appl_6 appl_7) !appl_9 <- appl_8 `pseq` hd appl_8 !appl_10 <- kl_Parse_Char `pseq` nToString kl_Parse_Char appl_9 `pseq` (appl_10 `pseq` kl_shen_pair appl_9 appl_10) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_11 <- kl_V2322 `pseq` hd kl_V2322 !appl_12 <- appl_11 `pseq` hd appl_11 appl_12 `pseq` applyWrapper appl_2 [appl_12] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBnumberRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBnumberRB (!kl_V2324) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_4 <- kl_fail !kl_if_5 <- kl_YaccParse `pseq` (appl_4 `pseq` eq kl_YaccParse appl_4) case kl_if_5 of Atom (B (True)) -> do let !appl_6 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_7 <- kl_fail !kl_if_8 <- kl_YaccParse `pseq` (appl_7 `pseq` eq kl_YaccParse appl_7) case kl_if_8 of Atom (B (True)) -> do let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_10 <- kl_fail !kl_if_11 <- kl_YaccParse `pseq` (appl_10 `pseq` eq kl_YaccParse appl_10) case kl_if_11 of Atom (B (True)) -> do let !appl_12 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_13 <- kl_fail !kl_if_14 <- kl_YaccParse `pseq` (appl_13 `pseq` eq kl_YaccParse appl_13) case kl_if_14 of Atom (B (True)) -> do let !appl_15 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_16 <- kl_fail !appl_17 <- appl_16 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_16 kl_Parse_shen_LBdigitsRB) !kl_if_18 <- appl_17 `pseq` kl_not appl_17 case kl_if_18 of Atom (B (True)) -> do !appl_19 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_20 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB !appl_21 <- appl_20 `pseq` kl_reverse appl_20 !appl_22 <- appl_21 `pseq` kl_shen_pre appl_21 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_19 `pseq` (appl_22 `pseq` kl_shen_pair appl_19 appl_22) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_23 <- kl_V2324 `pseq` kl_shen_LBdigitsRB kl_V2324 appl_23 `pseq` applyWrapper appl_15 [appl_23] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_24 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBpredigitsRB) -> do !appl_25 <- kl_fail !appl_26 <- appl_25 `pseq` (kl_Parse_shen_LBpredigitsRB `pseq` eq appl_25 kl_Parse_shen_LBpredigitsRB) !kl_if_27 <- appl_26 `pseq` kl_not appl_26 case kl_if_27 of Atom (B (True)) -> do let !appl_28 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstopRB) -> do !appl_29 <- kl_fail !appl_30 <- appl_29 `pseq` (kl_Parse_shen_LBstopRB `pseq` eq appl_29 kl_Parse_shen_LBstopRB) !kl_if_31 <- appl_30 `pseq` kl_not appl_30 case kl_if_31 of Atom (B (True)) -> do let !appl_32 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBpostdigitsRB) -> do !appl_33 <- kl_fail !appl_34 <- appl_33 `pseq` (kl_Parse_shen_LBpostdigitsRB `pseq` eq appl_33 kl_Parse_shen_LBpostdigitsRB) !kl_if_35 <- appl_34 `pseq` kl_not appl_34 case kl_if_35 of Atom (B (True)) -> do !appl_36 <- kl_Parse_shen_LBpostdigitsRB `pseq` hd kl_Parse_shen_LBpostdigitsRB !appl_37 <- kl_Parse_shen_LBpredigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBpredigitsRB !appl_38 <- appl_37 `pseq` kl_reverse appl_37 !appl_39 <- appl_38 `pseq` kl_shen_pre appl_38 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) !appl_40 <- kl_Parse_shen_LBpostdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBpostdigitsRB !appl_41 <- appl_40 `pseq` kl_shen_post appl_40 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_42 <- appl_39 `pseq` (appl_41 `pseq` add appl_39 appl_41) appl_36 `pseq` (appl_42 `pseq` kl_shen_pair appl_36 appl_42) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_43 <- kl_Parse_shen_LBstopRB `pseq` kl_shen_LBpostdigitsRB kl_Parse_shen_LBstopRB appl_43 `pseq` applyWrapper appl_32 [appl_43] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_44 <- kl_Parse_shen_LBpredigitsRB `pseq` kl_shen_LBstopRB kl_Parse_shen_LBpredigitsRB appl_44 `pseq` applyWrapper appl_28 [appl_44] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_45 <- kl_V2324 `pseq` kl_shen_LBpredigitsRB kl_V2324 !appl_46 <- appl_45 `pseq` applyWrapper appl_24 [appl_45] appl_46 `pseq` applyWrapper appl_12 [appl_46] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_47 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_48 <- kl_fail !appl_49 <- appl_48 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_48 kl_Parse_shen_LBdigitsRB) !kl_if_50 <- appl_49 `pseq` kl_not appl_49 case kl_if_50 of Atom (B (True)) -> do let !appl_51 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBERB) -> do !appl_52 <- kl_fail !appl_53 <- appl_52 `pseq` (kl_Parse_shen_LBERB `pseq` eq appl_52 kl_Parse_shen_LBERB) !kl_if_54 <- appl_53 `pseq` kl_not appl_53 case kl_if_54 of Atom (B (True)) -> do let !appl_55 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBlog10RB) -> do !appl_56 <- kl_fail !appl_57 <- appl_56 `pseq` (kl_Parse_shen_LBlog10RB `pseq` eq appl_56 kl_Parse_shen_LBlog10RB) !kl_if_58 <- appl_57 `pseq` kl_not appl_57 case kl_if_58 of Atom (B (True)) -> do !appl_59 <- kl_Parse_shen_LBlog10RB `pseq` hd kl_Parse_shen_LBlog10RB !appl_60 <- kl_Parse_shen_LBlog10RB `pseq` kl_shen_hdtl kl_Parse_shen_LBlog10RB !appl_61 <- appl_60 `pseq` kl_shen_expt (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_60 !appl_62 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB !appl_63 <- appl_62 `pseq` kl_reverse appl_62 !appl_64 <- appl_63 `pseq` kl_shen_pre appl_63 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) !appl_65 <- appl_61 `pseq` (appl_64 `pseq` multiply appl_61 appl_64) appl_59 `pseq` (appl_65 `pseq` kl_shen_pair appl_59 appl_65) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_66 <- kl_Parse_shen_LBERB `pseq` kl_shen_LBlog10RB kl_Parse_shen_LBERB appl_66 `pseq` applyWrapper appl_55 [appl_66] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_67 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_LBERB kl_Parse_shen_LBdigitsRB appl_67 `pseq` applyWrapper appl_51 [appl_67] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_68 <- kl_V2324 `pseq` kl_shen_LBdigitsRB kl_V2324 !appl_69 <- appl_68 `pseq` applyWrapper appl_47 [appl_68] appl_69 `pseq` applyWrapper appl_9 [appl_69] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_70 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBpredigitsRB) -> do !appl_71 <- kl_fail !appl_72 <- appl_71 `pseq` (kl_Parse_shen_LBpredigitsRB `pseq` eq appl_71 kl_Parse_shen_LBpredigitsRB) !kl_if_73 <- appl_72 `pseq` kl_not appl_72 case kl_if_73 of Atom (B (True)) -> do let !appl_74 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBstopRB) -> do !appl_75 <- kl_fail !appl_76 <- appl_75 `pseq` (kl_Parse_shen_LBstopRB `pseq` eq appl_75 kl_Parse_shen_LBstopRB) !kl_if_77 <- appl_76 `pseq` kl_not appl_76 case kl_if_77 of Atom (B (True)) -> do let !appl_78 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBpostdigitsRB) -> do !appl_79 <- kl_fail !appl_80 <- appl_79 `pseq` (kl_Parse_shen_LBpostdigitsRB `pseq` eq appl_79 kl_Parse_shen_LBpostdigitsRB) !kl_if_81 <- appl_80 `pseq` kl_not appl_80 case kl_if_81 of Atom (B (True)) -> do let !appl_82 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBERB) -> do !appl_83 <- kl_fail !appl_84 <- appl_83 `pseq` (kl_Parse_shen_LBERB `pseq` eq appl_83 kl_Parse_shen_LBERB) !kl_if_85 <- appl_84 `pseq` kl_not appl_84 case kl_if_85 of Atom (B (True)) -> do let !appl_86 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBlog10RB) -> do !appl_87 <- kl_fail !appl_88 <- appl_87 `pseq` (kl_Parse_shen_LBlog10RB `pseq` eq appl_87 kl_Parse_shen_LBlog10RB) !kl_if_89 <- appl_88 `pseq` kl_not appl_88 case kl_if_89 of Atom (B (True)) -> do !appl_90 <- kl_Parse_shen_LBlog10RB `pseq` hd kl_Parse_shen_LBlog10RB !appl_91 <- kl_Parse_shen_LBlog10RB `pseq` kl_shen_hdtl kl_Parse_shen_LBlog10RB !appl_92 <- appl_91 `pseq` kl_shen_expt (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_91 !appl_93 <- kl_Parse_shen_LBpredigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBpredigitsRB !appl_94 <- appl_93 `pseq` kl_reverse appl_93 !appl_95 <- appl_94 `pseq` kl_shen_pre appl_94 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) !appl_96 <- kl_Parse_shen_LBpostdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBpostdigitsRB !appl_97 <- appl_96 `pseq` kl_shen_post appl_96 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_98 <- appl_95 `pseq` (appl_97 `pseq` add appl_95 appl_97) !appl_99 <- appl_92 `pseq` (appl_98 `pseq` multiply appl_92 appl_98) appl_90 `pseq` (appl_99 `pseq` kl_shen_pair appl_90 appl_99) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_100 <- kl_Parse_shen_LBERB `pseq` kl_shen_LBlog10RB kl_Parse_shen_LBERB appl_100 `pseq` applyWrapper appl_86 [appl_100] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_101 <- kl_Parse_shen_LBpostdigitsRB `pseq` kl_shen_LBERB kl_Parse_shen_LBpostdigitsRB appl_101 `pseq` applyWrapper appl_82 [appl_101] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_102 <- kl_Parse_shen_LBstopRB `pseq` kl_shen_LBpostdigitsRB kl_Parse_shen_LBstopRB appl_102 `pseq` applyWrapper appl_78 [appl_102] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_103 <- kl_Parse_shen_LBpredigitsRB `pseq` kl_shen_LBstopRB kl_Parse_shen_LBpredigitsRB appl_103 `pseq` applyWrapper appl_74 [appl_103] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_104 <- kl_V2324 `pseq` kl_shen_LBpredigitsRB kl_V2324 !appl_105 <- appl_104 `pseq` applyWrapper appl_70 [appl_104] appl_105 `pseq` applyWrapper appl_6 [appl_105] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_106 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBplusRB) -> do !appl_107 <- kl_fail !appl_108 <- appl_107 `pseq` (kl_Parse_shen_LBplusRB `pseq` eq appl_107 kl_Parse_shen_LBplusRB) !kl_if_109 <- appl_108 `pseq` kl_not appl_108 case kl_if_109 of Atom (B (True)) -> do let !appl_110 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBnumberRB) -> do !appl_111 <- kl_fail !appl_112 <- appl_111 `pseq` (kl_Parse_shen_LBnumberRB `pseq` eq appl_111 kl_Parse_shen_LBnumberRB) !kl_if_113 <- appl_112 `pseq` kl_not appl_112 case kl_if_113 of Atom (B (True)) -> do !appl_114 <- kl_Parse_shen_LBnumberRB `pseq` hd kl_Parse_shen_LBnumberRB !appl_115 <- kl_Parse_shen_LBnumberRB `pseq` kl_shen_hdtl kl_Parse_shen_LBnumberRB appl_114 `pseq` (appl_115 `pseq` kl_shen_pair appl_114 appl_115) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_116 <- kl_Parse_shen_LBplusRB `pseq` kl_shen_LBnumberRB kl_Parse_shen_LBplusRB appl_116 `pseq` applyWrapper appl_110 [appl_116] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_117 <- kl_V2324 `pseq` kl_shen_LBplusRB kl_V2324 !appl_118 <- appl_117 `pseq` applyWrapper appl_106 [appl_117] appl_118 `pseq` applyWrapper appl_3 [appl_118] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_119 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBminusRB) -> do !appl_120 <- kl_fail !appl_121 <- appl_120 `pseq` (kl_Parse_shen_LBminusRB `pseq` eq appl_120 kl_Parse_shen_LBminusRB) !kl_if_122 <- appl_121 `pseq` kl_not appl_121 case kl_if_122 of Atom (B (True)) -> do let !appl_123 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBnumberRB) -> do !appl_124 <- kl_fail !appl_125 <- appl_124 `pseq` (kl_Parse_shen_LBnumberRB `pseq` eq appl_124 kl_Parse_shen_LBnumberRB) !kl_if_126 <- appl_125 `pseq` kl_not appl_125 case kl_if_126 of Atom (B (True)) -> do !appl_127 <- kl_Parse_shen_LBnumberRB `pseq` hd kl_Parse_shen_LBnumberRB !appl_128 <- kl_Parse_shen_LBnumberRB `pseq` kl_shen_hdtl kl_Parse_shen_LBnumberRB !appl_129 <- appl_128 `pseq` Primitives.subtract (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_128 appl_127 `pseq` (appl_129 `pseq` kl_shen_pair appl_127 appl_129) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_130 <- kl_Parse_shen_LBminusRB `pseq` kl_shen_LBnumberRB kl_Parse_shen_LBminusRB appl_130 `pseq` applyWrapper appl_123 [appl_130] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_131 <- kl_V2324 `pseq` kl_shen_LBminusRB kl_V2324 !appl_132 <- appl_131 `pseq` applyWrapper appl_119 [appl_131] appl_132 `pseq` applyWrapper appl_0 [appl_132] kl_shen_LBERB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBERB (!kl_V2326) = do !appl_0 <- kl_V2326 `pseq` hd kl_V2326 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2326 `pseq` hd kl_V2326 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 101))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2326 `pseq` hd kl_V2326 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2326 `pseq` kl_shen_hdtl kl_V2326 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBlog10RB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBlog10RB (!kl_V2328) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_4 kl_Parse_shen_LBdigitsRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_8 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB !appl_9 <- appl_8 `pseq` kl_reverse appl_8 !appl_10 <- appl_9 `pseq` kl_shen_pre appl_9 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_7 `pseq` (appl_10 `pseq` kl_shen_pair appl_7 appl_10) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_11 <- kl_V2328 `pseq` kl_shen_LBdigitsRB kl_V2328 appl_11 `pseq` applyWrapper appl_3 [appl_11] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_12 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBminusRB) -> do !appl_13 <- kl_fail !appl_14 <- appl_13 `pseq` (kl_Parse_shen_LBminusRB `pseq` eq appl_13 kl_Parse_shen_LBminusRB) !kl_if_15 <- appl_14 `pseq` kl_not appl_14 case kl_if_15 of Atom (B (True)) -> do let !appl_16 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_17 <- kl_fail !appl_18 <- appl_17 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_17 kl_Parse_shen_LBdigitsRB) !kl_if_19 <- appl_18 `pseq` kl_not appl_18 case kl_if_19 of Atom (B (True)) -> do !appl_20 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_21 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB !appl_22 <- appl_21 `pseq` kl_reverse appl_21 !appl_23 <- appl_22 `pseq` kl_shen_pre appl_22 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) !appl_24 <- appl_23 `pseq` Primitives.subtract (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) appl_23 appl_20 `pseq` (appl_24 `pseq` kl_shen_pair appl_20 appl_24) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_25 <- kl_Parse_shen_LBminusRB `pseq` kl_shen_LBdigitsRB kl_Parse_shen_LBminusRB appl_25 `pseq` applyWrapper appl_16 [appl_25] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_26 <- kl_V2328 `pseq` kl_shen_LBminusRB kl_V2328 !appl_27 <- appl_26 `pseq` applyWrapper appl_12 [appl_26] appl_27 `pseq` applyWrapper appl_0 [appl_27] kl_shen_LBplusRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBplusRB (!kl_V2330) = do !appl_0 <- kl_V2330 `pseq` hd kl_V2330 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do let pat_cond_3 = do !appl_4 <- kl_V2330 `pseq` hd kl_V2330 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2330 `pseq` kl_shen_hdtl kl_V2330 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 appl_8 `pseq` (kl_Parse_Char `pseq` kl_shen_pair appl_8 kl_Parse_Char) pat_cond_9 = do do kl_fail in case kl_Parse_Char of kl_Parse_Char@(Atom (N (KI 43))) -> pat_cond_3 _ -> pat_cond_9))) !appl_10 <- kl_V2330 `pseq` hd kl_V2330 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBstopRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBstopRB (!kl_V2332) = do !appl_0 <- kl_V2332 `pseq` hd kl_V2332 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_Char) -> do let pat_cond_3 = do !appl_4 <- kl_V2332 `pseq` hd kl_V2332 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2332 `pseq` kl_shen_hdtl kl_V2332 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 appl_8 `pseq` (kl_Parse_Char `pseq` kl_shen_pair appl_8 kl_Parse_Char) pat_cond_9 = do do kl_fail in case kl_Parse_Char of kl_Parse_Char@(Atom (N (KI 46))) -> pat_cond_3 _ -> pat_cond_9))) !appl_10 <- kl_V2332 `pseq` hd kl_V2332 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBpredigitsRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBpredigitsRB (!kl_V2334) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_LBeRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_LBeRB `pseq` eq appl_4 kl_Parse_LBeRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_LBeRB `pseq` hd kl_Parse_LBeRB let !appl_8 = Atom Nil appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_9 <- kl_V2334 `pseq` kl_LBeRB kl_V2334 appl_9 `pseq` applyWrapper appl_3 [appl_9] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_10 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_11 <- kl_fail !appl_12 <- appl_11 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_11 kl_Parse_shen_LBdigitsRB) !kl_if_13 <- appl_12 `pseq` kl_not appl_12 case kl_if_13 of Atom (B (True)) -> do !appl_14 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_15 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB appl_14 `pseq` (appl_15 `pseq` kl_shen_pair appl_14 appl_15) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_16 <- kl_V2334 `pseq` kl_shen_LBdigitsRB kl_V2334 !appl_17 <- appl_16 `pseq` applyWrapper appl_10 [appl_16] appl_17 `pseq` applyWrapper appl_0 [appl_17] kl_shen_LBpostdigitsRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBpostdigitsRB (!kl_V2336) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_1 kl_Parse_shen_LBdigitsRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_5 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB appl_4 `pseq` (appl_5 `pseq` kl_shen_pair appl_4 appl_5) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_6 <- kl_V2336 `pseq` kl_shen_LBdigitsRB kl_V2336 appl_6 `pseq` applyWrapper appl_0 [appl_6] kl_shen_LBdigitsRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBdigitsRB (!kl_V2338) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_shen_LBdigitRB `pseq` eq appl_4 kl_Parse_shen_LBdigitRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_shen_LBdigitRB `pseq` hd kl_Parse_shen_LBdigitRB !appl_8 <- kl_Parse_shen_LBdigitRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitRB let !appl_9 = Atom Nil !appl_10 <- appl_8 `pseq` (appl_9 `pseq` klCons appl_8 appl_9) appl_7 `pseq` (appl_10 `pseq` kl_shen_pair appl_7 appl_10) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_11 <- kl_V2338 `pseq` kl_shen_LBdigitRB kl_V2338 appl_11 `pseq` applyWrapper appl_3 [appl_11] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_12 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitRB) -> do !appl_13 <- kl_fail !appl_14 <- appl_13 `pseq` (kl_Parse_shen_LBdigitRB `pseq` eq appl_13 kl_Parse_shen_LBdigitRB) !kl_if_15 <- appl_14 `pseq` kl_not appl_14 case kl_if_15 of Atom (B (True)) -> do let !appl_16 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBdigitsRB) -> do !appl_17 <- kl_fail !appl_18 <- appl_17 `pseq` (kl_Parse_shen_LBdigitsRB `pseq` eq appl_17 kl_Parse_shen_LBdigitsRB) !kl_if_19 <- appl_18 `pseq` kl_not appl_18 case kl_if_19 of Atom (B (True)) -> do !appl_20 <- kl_Parse_shen_LBdigitsRB `pseq` hd kl_Parse_shen_LBdigitsRB !appl_21 <- kl_Parse_shen_LBdigitRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitRB !appl_22 <- kl_Parse_shen_LBdigitsRB `pseq` kl_shen_hdtl kl_Parse_shen_LBdigitsRB !appl_23 <- appl_21 `pseq` (appl_22 `pseq` klCons appl_21 appl_22) appl_20 `pseq` (appl_23 `pseq` kl_shen_pair appl_20 appl_23) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_24 <- kl_Parse_shen_LBdigitRB `pseq` kl_shen_LBdigitsRB kl_Parse_shen_LBdigitRB appl_24 `pseq` applyWrapper appl_16 [appl_24] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_25 <- kl_V2338 `pseq` kl_shen_LBdigitRB kl_V2338 !appl_26 <- appl_25 `pseq` applyWrapper appl_12 [appl_25] appl_26 `pseq` applyWrapper appl_0 [appl_26] kl_shen_LBdigitRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBdigitRB (!kl_V2340) = do !appl_0 <- kl_V2340 `pseq` hd kl_V2340 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_X) -> do !kl_if_3 <- kl_Parse_X `pseq` kl_shen_numbyteP kl_Parse_X case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_V2340 `pseq` hd kl_V2340 !appl_5 <- appl_4 `pseq` tl appl_4 !appl_6 <- kl_V2340 `pseq` kl_shen_hdtl kl_V2340 !appl_7 <- appl_5 `pseq` (appl_6 `pseq` kl_shen_pair appl_5 appl_6) !appl_8 <- appl_7 `pseq` hd appl_7 !appl_9 <- kl_Parse_X `pseq` kl_shen_byte_RBdigit kl_Parse_X appl_8 `pseq` (appl_9 `pseq` kl_shen_pair appl_8 appl_9) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_10 <- kl_V2340 `pseq` hd kl_V2340 !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` applyWrapper appl_2 [appl_11] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_byte_RBdigit :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_byte_RBdigit (!kl_V2342) = do let pat_cond_0 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) pat_cond_1 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) pat_cond_2 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 2))) pat_cond_3 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 3))) pat_cond_4 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 4))) pat_cond_5 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 5))) pat_cond_6 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 6))) pat_cond_7 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 7))) pat_cond_8 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 8))) pat_cond_9 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 9))) pat_cond_10 = do do let !aw_11 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_11 [ApplC (wrapNamed "shen.byte->digit" kl_shen_byte_RBdigit)] in case kl_V2342 of kl_V2342@(Atom (N (KI 48))) -> pat_cond_0 kl_V2342@(Atom (N (KI 49))) -> pat_cond_1 kl_V2342@(Atom (N (KI 50))) -> pat_cond_2 kl_V2342@(Atom (N (KI 51))) -> pat_cond_3 kl_V2342@(Atom (N (KI 52))) -> pat_cond_4 kl_V2342@(Atom (N (KI 53))) -> pat_cond_5 kl_V2342@(Atom (N (KI 54))) -> pat_cond_6 kl_V2342@(Atom (N (KI 55))) -> pat_cond_7 kl_V2342@(Atom (N (KI 56))) -> pat_cond_8 kl_V2342@(Atom (N (KI 57))) -> pat_cond_9 _ -> pat_cond_10 kl_shen_pre :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_pre (!kl_V2347) (!kl_V2348) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2347 `pseq` eq appl_0 kl_V2347) case kl_if_1 of Atom (B (True)) -> do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) Atom (B (False)) -> do let pat_cond_2 kl_V2347 kl_V2347h kl_V2347t = do !appl_3 <- kl_V2348 `pseq` kl_shen_expt (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) kl_V2348 !appl_4 <- appl_3 `pseq` (kl_V2347h `pseq` multiply appl_3 kl_V2347h) !appl_5 <- kl_V2348 `pseq` add kl_V2348 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_6 <- kl_V2347t `pseq` (appl_5 `pseq` kl_shen_pre kl_V2347t appl_5) appl_4 `pseq` (appl_6 `pseq` add appl_4 appl_6) pat_cond_7 = do do let !aw_8 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_8 [ApplC (wrapNamed "shen.pre" kl_shen_pre)] in case kl_V2347 of !(kl_V2347@(Cons (!kl_V2347h) (!kl_V2347t))) -> pat_cond_2 kl_V2347 kl_V2347h kl_V2347t _ -> pat_cond_7 _ -> throwError "if: expected boolean" kl_shen_post :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_post (!kl_V2353) (!kl_V2354) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2353 `pseq` eq appl_0 kl_V2353) case kl_if_1 of Atom (B (True)) -> do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) Atom (B (False)) -> do let pat_cond_2 kl_V2353 kl_V2353h kl_V2353t = do !appl_3 <- kl_V2354 `pseq` Primitives.subtract (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) kl_V2354 !appl_4 <- appl_3 `pseq` kl_shen_expt (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_3 !appl_5 <- appl_4 `pseq` (kl_V2353h `pseq` multiply appl_4 kl_V2353h) !appl_6 <- kl_V2354 `pseq` add kl_V2354 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_7 <- kl_V2353t `pseq` (appl_6 `pseq` kl_shen_post kl_V2353t appl_6) appl_5 `pseq` (appl_7 `pseq` add appl_5 appl_7) pat_cond_8 = do do let !aw_9 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_9 [ApplC (wrapNamed "shen.post" kl_shen_post)] in case kl_V2353 of !(kl_V2353@(Cons (!kl_V2353h) (!kl_V2353t))) -> pat_cond_2 kl_V2353 kl_V2353h kl_V2353t _ -> pat_cond_8 _ -> throwError "if: expected boolean" kl_shen_expt :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_expt (!kl_V2359) (!kl_V2360) = do let pat_cond_0 = do return (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) pat_cond_1 = do !kl_if_2 <- kl_V2360 `pseq` greaterThan kl_V2360 (Core.Types.Atom (Core.Types.N (Core.Types.KI 0))) case kl_if_2 of Atom (B (True)) -> do !appl_3 <- kl_V2360 `pseq` Primitives.subtract kl_V2360 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_4 <- kl_V2359 `pseq` (appl_3 `pseq` kl_shen_expt kl_V2359 appl_3) kl_V2359 `pseq` (appl_4 `pseq` multiply kl_V2359 appl_4) Atom (B (False)) -> do do !appl_5 <- kl_V2360 `pseq` add kl_V2360 (Core.Types.Atom (Core.Types.N (Core.Types.KI 1))) !appl_6 <- kl_V2359 `pseq` (appl_5 `pseq` kl_shen_expt kl_V2359 appl_5) !appl_7 <- appl_6 `pseq` (kl_V2359 `pseq` divide appl_6 kl_V2359) appl_7 `pseq` multiply (Core.Types.Atom (Core.Types.N (Core.Types.KD 1.0))) appl_7 _ -> throwError "if: expected boolean" in case kl_V2360 of kl_V2360@(Atom (N (KI 0))) -> pat_cond_0 _ -> pat_cond_1 kl_shen_LBst_input1RB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBst_input1RB (!kl_V2362) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_1 kl_Parse_shen_LBst_inputRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_5 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB appl_4 `pseq` (appl_5 `pseq` kl_shen_pair appl_4 appl_5) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_6 <- kl_V2362 `pseq` kl_shen_LBst_inputRB kl_V2362 appl_6 `pseq` applyWrapper appl_0 [appl_6] kl_shen_LBst_input2RB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBst_input2RB (!kl_V2364) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBst_inputRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBst_inputRB `pseq` eq appl_1 kl_Parse_shen_LBst_inputRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do !appl_4 <- kl_Parse_shen_LBst_inputRB `pseq` hd kl_Parse_shen_LBst_inputRB !appl_5 <- kl_Parse_shen_LBst_inputRB `pseq` kl_shen_hdtl kl_Parse_shen_LBst_inputRB appl_4 `pseq` (appl_5 `pseq` kl_shen_pair appl_4 appl_5) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_6 <- kl_V2364 `pseq` kl_shen_LBst_inputRB kl_V2364 appl_6 `pseq` applyWrapper appl_0 [appl_6] kl_shen_LBcommentRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBcommentRB (!kl_V2366) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBmultilineRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_shen_LBmultilineRB `pseq` eq appl_4 kl_Parse_shen_LBmultilineRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_shen_LBmultilineRB `pseq` hd kl_Parse_shen_LBmultilineRB appl_7 `pseq` kl_shen_pair appl_7 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_8 <- kl_V2366 `pseq` kl_shen_LBmultilineRB kl_V2366 appl_8 `pseq` applyWrapper appl_3 [appl_8] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBsinglelineRB) -> do !appl_10 <- kl_fail !appl_11 <- appl_10 `pseq` (kl_Parse_shen_LBsinglelineRB `pseq` eq appl_10 kl_Parse_shen_LBsinglelineRB) !kl_if_12 <- appl_11 `pseq` kl_not appl_11 case kl_if_12 of Atom (B (True)) -> do !appl_13 <- kl_Parse_shen_LBsinglelineRB `pseq` hd kl_Parse_shen_LBsinglelineRB appl_13 `pseq` kl_shen_pair appl_13 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_14 <- kl_V2366 `pseq` kl_shen_LBsinglelineRB kl_V2366 !appl_15 <- appl_14 `pseq` applyWrapper appl_9 [appl_14] appl_15 `pseq` applyWrapper appl_0 [appl_15] kl_shen_LBsinglelineRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBsinglelineRB (!kl_V2368) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBbackslashRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBbackslashRB `pseq` eq appl_1 kl_Parse_shen_LBbackslashRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBbackslashRB) -> do !appl_5 <- kl_fail !appl_6 <- appl_5 `pseq` (kl_Parse_shen_LBbackslashRB `pseq` eq appl_5 kl_Parse_shen_LBbackslashRB) !kl_if_7 <- appl_6 `pseq` kl_not appl_6 case kl_if_7 of Atom (B (True)) -> do let !appl_8 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBanysingleRB) -> do !appl_9 <- kl_fail !appl_10 <- appl_9 `pseq` (kl_Parse_shen_LBanysingleRB `pseq` eq appl_9 kl_Parse_shen_LBanysingleRB) !kl_if_11 <- appl_10 `pseq` kl_not appl_10 case kl_if_11 of Atom (B (True)) -> do let !appl_12 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBreturnRB) -> do !appl_13 <- kl_fail !appl_14 <- appl_13 `pseq` (kl_Parse_shen_LBreturnRB `pseq` eq appl_13 kl_Parse_shen_LBreturnRB) !kl_if_15 <- appl_14 `pseq` kl_not appl_14 case kl_if_15 of Atom (B (True)) -> do !appl_16 <- kl_Parse_shen_LBreturnRB `pseq` hd kl_Parse_shen_LBreturnRB appl_16 `pseq` kl_shen_pair appl_16 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_17 <- kl_Parse_shen_LBanysingleRB `pseq` kl_shen_LBreturnRB kl_Parse_shen_LBanysingleRB appl_17 `pseq` applyWrapper appl_12 [appl_17] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_18 <- kl_Parse_shen_LBbackslashRB `pseq` kl_shen_LBanysingleRB kl_Parse_shen_LBbackslashRB appl_18 `pseq` applyWrapper appl_8 [appl_18] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_19 <- kl_Parse_shen_LBbackslashRB `pseq` kl_shen_LBbackslashRB kl_Parse_shen_LBbackslashRB appl_19 `pseq` applyWrapper appl_4 [appl_19] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_20 <- kl_V2368 `pseq` kl_shen_LBbackslashRB kl_V2368 appl_20 `pseq` applyWrapper appl_0 [appl_20] kl_shen_LBbackslashRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBbackslashRB (!kl_V2370) = do !appl_0 <- kl_V2370 `pseq` hd kl_V2370 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2370 `pseq` hd kl_V2370 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 92))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2370 `pseq` hd kl_V2370 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2370 `pseq` kl_shen_hdtl kl_V2370 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBanysingleRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBanysingleRB (!kl_V2372) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_LBeRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_LBeRB `pseq` eq appl_4 kl_Parse_LBeRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_LBeRB `pseq` hd kl_Parse_LBeRB appl_7 `pseq` kl_shen_pair appl_7 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_8 <- kl_V2372 `pseq` kl_LBeRB kl_V2372 appl_8 `pseq` applyWrapper appl_3 [appl_8] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBnon_returnRB) -> do !appl_10 <- kl_fail !appl_11 <- appl_10 `pseq` (kl_Parse_shen_LBnon_returnRB `pseq` eq appl_10 kl_Parse_shen_LBnon_returnRB) !kl_if_12 <- appl_11 `pseq` kl_not appl_11 case kl_if_12 of Atom (B (True)) -> do let !appl_13 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBanysingleRB) -> do !appl_14 <- kl_fail !appl_15 <- appl_14 `pseq` (kl_Parse_shen_LBanysingleRB `pseq` eq appl_14 kl_Parse_shen_LBanysingleRB) !kl_if_16 <- appl_15 `pseq` kl_not appl_15 case kl_if_16 of Atom (B (True)) -> do !appl_17 <- kl_Parse_shen_LBanysingleRB `pseq` hd kl_Parse_shen_LBanysingleRB appl_17 `pseq` kl_shen_pair appl_17 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_18 <- kl_Parse_shen_LBnon_returnRB `pseq` kl_shen_LBanysingleRB kl_Parse_shen_LBnon_returnRB appl_18 `pseq` applyWrapper appl_13 [appl_18] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_19 <- kl_V2372 `pseq` kl_shen_LBnon_returnRB kl_V2372 !appl_20 <- appl_19 `pseq` applyWrapper appl_9 [appl_19] appl_20 `pseq` applyWrapper appl_0 [appl_20] kl_shen_LBnon_returnRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBnon_returnRB (!kl_V2374) = do !appl_0 <- kl_V2374 `pseq` hd kl_V2374 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_X) -> do let !appl_3 = Atom Nil !appl_4 <- appl_3 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 13))) appl_3 !appl_5 <- appl_4 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_4 !appl_6 <- kl_Parse_X `pseq` (appl_5 `pseq` kl_elementP kl_Parse_X appl_5) !kl_if_7 <- appl_6 `pseq` kl_not appl_6 case kl_if_7 of Atom (B (True)) -> do !appl_8 <- kl_V2374 `pseq` hd kl_V2374 !appl_9 <- appl_8 `pseq` tl appl_8 !appl_10 <- kl_V2374 `pseq` kl_shen_hdtl kl_V2374 !appl_11 <- appl_9 `pseq` (appl_10 `pseq` kl_shen_pair appl_9 appl_10) !appl_12 <- appl_11 `pseq` hd appl_11 appl_12 `pseq` kl_shen_pair appl_12 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_13 <- kl_V2374 `pseq` hd kl_V2374 !appl_14 <- appl_13 `pseq` hd appl_13 appl_14 `pseq` applyWrapper appl_2 [appl_14] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBreturnRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBreturnRB (!kl_V2376) = do !appl_0 <- kl_V2376 `pseq` hd kl_V2376 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_X) -> do let !appl_3 = Atom Nil !appl_4 <- appl_3 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 13))) appl_3 !appl_5 <- appl_4 `pseq` klCons (Core.Types.Atom (Core.Types.N (Core.Types.KI 10))) appl_4 !kl_if_6 <- kl_Parse_X `pseq` (appl_5 `pseq` kl_elementP kl_Parse_X appl_5) case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_V2376 `pseq` hd kl_V2376 !appl_8 <- appl_7 `pseq` tl appl_7 !appl_9 <- kl_V2376 `pseq` kl_shen_hdtl kl_V2376 !appl_10 <- appl_8 `pseq` (appl_9 `pseq` kl_shen_pair appl_8 appl_9) !appl_11 <- appl_10 `pseq` hd appl_10 appl_11 `pseq` kl_shen_pair appl_11 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_12 <- kl_V2376 `pseq` hd kl_V2376 !appl_13 <- appl_12 `pseq` hd appl_12 appl_13 `pseq` applyWrapper appl_2 [appl_13] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBmultilineRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBmultilineRB (!kl_V2378) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBbackslashRB) -> do !appl_1 <- kl_fail !appl_2 <- appl_1 `pseq` (kl_Parse_shen_LBbackslashRB `pseq` eq appl_1 kl_Parse_shen_LBbackslashRB) !kl_if_3 <- appl_2 `pseq` kl_not appl_2 case kl_if_3 of Atom (B (True)) -> do let !appl_4 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBtimesRB) -> do !appl_5 <- kl_fail !appl_6 <- appl_5 `pseq` (kl_Parse_shen_LBtimesRB `pseq` eq appl_5 kl_Parse_shen_LBtimesRB) !kl_if_7 <- appl_6 `pseq` kl_not appl_6 case kl_if_7 of Atom (B (True)) -> do let !appl_8 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBanymultiRB) -> do !appl_9 <- kl_fail !appl_10 <- appl_9 `pseq` (kl_Parse_shen_LBanymultiRB `pseq` eq appl_9 kl_Parse_shen_LBanymultiRB) !kl_if_11 <- appl_10 `pseq` kl_not appl_10 case kl_if_11 of Atom (B (True)) -> do !appl_12 <- kl_Parse_shen_LBanymultiRB `pseq` hd kl_Parse_shen_LBanymultiRB appl_12 `pseq` kl_shen_pair appl_12 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_13 <- kl_Parse_shen_LBtimesRB `pseq` kl_shen_LBanymultiRB kl_Parse_shen_LBtimesRB appl_13 `pseq` applyWrapper appl_8 [appl_13] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_14 <- kl_Parse_shen_LBbackslashRB `pseq` kl_shen_LBtimesRB kl_Parse_shen_LBbackslashRB appl_14 `pseq` applyWrapper appl_4 [appl_14] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_15 <- kl_V2378 `pseq` kl_shen_LBbackslashRB kl_V2378 appl_15 `pseq` applyWrapper appl_0 [appl_15] kl_shen_LBtimesRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBtimesRB (!kl_V2380) = do !appl_0 <- kl_V2380 `pseq` hd kl_V2380 !kl_if_1 <- appl_0 `pseq` consP appl_0 !kl_if_2 <- case kl_if_1 of Atom (B (True)) -> do !appl_3 <- kl_V2380 `pseq` hd kl_V2380 !appl_4 <- appl_3 `pseq` hd appl_3 !kl_if_5 <- appl_4 `pseq` eq (Core.Types.Atom (Core.Types.N (Core.Types.KI 42))) appl_4 case kl_if_5 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_2 of Atom (B (True)) -> do !appl_6 <- kl_V2380 `pseq` hd kl_V2380 !appl_7 <- appl_6 `pseq` tl appl_6 !appl_8 <- kl_V2380 `pseq` kl_shen_hdtl kl_V2380 !appl_9 <- appl_7 `pseq` (appl_8 `pseq` kl_shen_pair appl_7 appl_8) !appl_10 <- appl_9 `pseq` hd appl_9 appl_10 `pseq` kl_shen_pair appl_10 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_LBanymultiRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBanymultiRB (!kl_V2382) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_4 <- kl_fail !kl_if_5 <- kl_YaccParse `pseq` (appl_4 `pseq` eq kl_YaccParse appl_4) case kl_if_5 of Atom (B (True)) -> do !appl_6 <- kl_V2382 `pseq` hd kl_V2382 !kl_if_7 <- appl_6 `pseq` consP appl_6 case kl_if_7 of Atom (B (True)) -> do let !appl_8 = ApplC (Func "lambda" (Context (\(!kl_Parse_X) -> do let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBanymultiRB) -> do !appl_10 <- kl_fail !appl_11 <- appl_10 `pseq` (kl_Parse_shen_LBanymultiRB `pseq` eq appl_10 kl_Parse_shen_LBanymultiRB) !kl_if_12 <- appl_11 `pseq` kl_not appl_11 case kl_if_12 of Atom (B (True)) -> do !appl_13 <- kl_Parse_shen_LBanymultiRB `pseq` hd kl_Parse_shen_LBanymultiRB appl_13 `pseq` kl_shen_pair appl_13 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_14 <- kl_V2382 `pseq` hd kl_V2382 !appl_15 <- appl_14 `pseq` tl appl_14 !appl_16 <- kl_V2382 `pseq` kl_shen_hdtl kl_V2382 !appl_17 <- appl_15 `pseq` (appl_16 `pseq` kl_shen_pair appl_15 appl_16) !appl_18 <- appl_17 `pseq` kl_shen_LBanymultiRB appl_17 appl_18 `pseq` applyWrapper appl_9 [appl_18]))) !appl_19 <- kl_V2382 `pseq` hd kl_V2382 !appl_20 <- appl_19 `pseq` hd appl_19 appl_20 `pseq` applyWrapper appl_8 [appl_20] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_21 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBtimesRB) -> do !appl_22 <- kl_fail !appl_23 <- appl_22 `pseq` (kl_Parse_shen_LBtimesRB `pseq` eq appl_22 kl_Parse_shen_LBtimesRB) !kl_if_24 <- appl_23 `pseq` kl_not appl_23 case kl_if_24 of Atom (B (True)) -> do let !appl_25 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBbackslashRB) -> do !appl_26 <- kl_fail !appl_27 <- appl_26 `pseq` (kl_Parse_shen_LBbackslashRB `pseq` eq appl_26 kl_Parse_shen_LBbackslashRB) !kl_if_28 <- appl_27 `pseq` kl_not appl_27 case kl_if_28 of Atom (B (True)) -> do !appl_29 <- kl_Parse_shen_LBbackslashRB `pseq` hd kl_Parse_shen_LBbackslashRB appl_29 `pseq` kl_shen_pair appl_29 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_30 <- kl_Parse_shen_LBtimesRB `pseq` kl_shen_LBbackslashRB kl_Parse_shen_LBtimesRB appl_30 `pseq` applyWrapper appl_25 [appl_30] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_31 <- kl_V2382 `pseq` kl_shen_LBtimesRB kl_V2382 !appl_32 <- appl_31 `pseq` applyWrapper appl_21 [appl_31] appl_32 `pseq` applyWrapper appl_3 [appl_32] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_33 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBcommentRB) -> do !appl_34 <- kl_fail !appl_35 <- appl_34 `pseq` (kl_Parse_shen_LBcommentRB `pseq` eq appl_34 kl_Parse_shen_LBcommentRB) !kl_if_36 <- appl_35 `pseq` kl_not appl_35 case kl_if_36 of Atom (B (True)) -> do let !appl_37 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBanymultiRB) -> do !appl_38 <- kl_fail !appl_39 <- appl_38 `pseq` (kl_Parse_shen_LBanymultiRB `pseq` eq appl_38 kl_Parse_shen_LBanymultiRB) !kl_if_40 <- appl_39 `pseq` kl_not appl_39 case kl_if_40 of Atom (B (True)) -> do !appl_41 <- kl_Parse_shen_LBanymultiRB `pseq` hd kl_Parse_shen_LBanymultiRB appl_41 `pseq` kl_shen_pair appl_41 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_42 <- kl_Parse_shen_LBcommentRB `pseq` kl_shen_LBanymultiRB kl_Parse_shen_LBcommentRB appl_42 `pseq` applyWrapper appl_37 [appl_42] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_43 <- kl_V2382 `pseq` kl_shen_LBcommentRB kl_V2382 !appl_44 <- appl_43 `pseq` applyWrapper appl_33 [appl_43] appl_44 `pseq` applyWrapper appl_0 [appl_44] kl_shen_LBwhitespacesRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBwhitespacesRB (!kl_V2384) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_YaccParse) -> do !appl_1 <- kl_fail !kl_if_2 <- kl_YaccParse `pseq` (appl_1 `pseq` eq kl_YaccParse appl_1) case kl_if_2 of Atom (B (True)) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBwhitespaceRB) -> do !appl_4 <- kl_fail !appl_5 <- appl_4 `pseq` (kl_Parse_shen_LBwhitespaceRB `pseq` eq appl_4 kl_Parse_shen_LBwhitespaceRB) !kl_if_6 <- appl_5 `pseq` kl_not appl_5 case kl_if_6 of Atom (B (True)) -> do !appl_7 <- kl_Parse_shen_LBwhitespaceRB `pseq` hd kl_Parse_shen_LBwhitespaceRB appl_7 `pseq` kl_shen_pair appl_7 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_8 <- kl_V2384 `pseq` kl_shen_LBwhitespaceRB kl_V2384 appl_8 `pseq` applyWrapper appl_3 [appl_8] Atom (B (False)) -> do do return kl_YaccParse _ -> throwError "if: expected boolean"))) let !appl_9 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBwhitespaceRB) -> do !appl_10 <- kl_fail !appl_11 <- appl_10 `pseq` (kl_Parse_shen_LBwhitespaceRB `pseq` eq appl_10 kl_Parse_shen_LBwhitespaceRB) !kl_if_12 <- appl_11 `pseq` kl_not appl_11 case kl_if_12 of Atom (B (True)) -> do let !appl_13 = ApplC (Func "lambda" (Context (\(!kl_Parse_shen_LBwhitespacesRB) -> do !appl_14 <- kl_fail !appl_15 <- appl_14 `pseq` (kl_Parse_shen_LBwhitespacesRB `pseq` eq appl_14 kl_Parse_shen_LBwhitespacesRB) !kl_if_16 <- appl_15 `pseq` kl_not appl_15 case kl_if_16 of Atom (B (True)) -> do !appl_17 <- kl_Parse_shen_LBwhitespacesRB `pseq` hd kl_Parse_shen_LBwhitespacesRB appl_17 `pseq` kl_shen_pair appl_17 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_18 <- kl_Parse_shen_LBwhitespaceRB `pseq` kl_shen_LBwhitespacesRB kl_Parse_shen_LBwhitespaceRB appl_18 `pseq` applyWrapper appl_13 [appl_18] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_19 <- kl_V2384 `pseq` kl_shen_LBwhitespaceRB kl_V2384 !appl_20 <- appl_19 `pseq` applyWrapper appl_9 [appl_19] appl_20 `pseq` applyWrapper appl_0 [appl_20] kl_shen_LBwhitespaceRB :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_LBwhitespaceRB (!kl_V2386) = do !appl_0 <- kl_V2386 `pseq` hd kl_V2386 !kl_if_1 <- appl_0 `pseq` consP appl_0 case kl_if_1 of Atom (B (True)) -> do let !appl_2 = ApplC (Func "lambda" (Context (\(!kl_Parse_X) -> do let !appl_3 = ApplC (Func "lambda" (Context (\(!kl_Parse_Case) -> do let pat_cond_4 = do return (Atom (B True)) pat_cond_5 = do do !kl_if_6 <- let pat_cond_7 = do return (Atom (B True)) pat_cond_8 = do do !kl_if_9 <- let pat_cond_10 = do return (Atom (B True)) pat_cond_11 = do do let pat_cond_12 = do return (Atom (B True)) pat_cond_13 = do do return (Atom (B False)) in case kl_Parse_Case of kl_Parse_Case@(Atom (N (KI 9))) -> pat_cond_12 _ -> pat_cond_13 in case kl_Parse_Case of kl_Parse_Case@(Atom (N (KI 10))) -> pat_cond_10 _ -> pat_cond_11 case kl_if_9 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" in case kl_Parse_Case of kl_Parse_Case@(Atom (N (KI 13))) -> pat_cond_7 _ -> pat_cond_8 case kl_if_6 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" in case kl_Parse_Case of kl_Parse_Case@(Atom (N (KI 32))) -> pat_cond_4 _ -> pat_cond_5))) !kl_if_14 <- kl_Parse_X `pseq` applyWrapper appl_3 [kl_Parse_X] case kl_if_14 of Atom (B (True)) -> do !appl_15 <- kl_V2386 `pseq` hd kl_V2386 !appl_16 <- appl_15 `pseq` tl appl_15 !appl_17 <- kl_V2386 `pseq` kl_shen_hdtl kl_V2386 !appl_18 <- appl_16 `pseq` (appl_17 `pseq` kl_shen_pair appl_16 appl_17) !appl_19 <- appl_18 `pseq` hd appl_18 appl_19 `pseq` kl_shen_pair appl_19 (Core.Types.Atom (Core.Types.UnboundSym "shen.skip")) Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean"))) !appl_20 <- kl_V2386 `pseq` hd kl_V2386 !appl_21 <- appl_20 `pseq` hd appl_20 appl_21 `pseq` applyWrapper appl_2 [appl_21] Atom (B (False)) -> do do kl_fail _ -> throwError "if: expected boolean" kl_shen_cons_form :: Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_cons_form (!kl_V2388) = do let !appl_0 = Atom Nil !kl_if_1 <- appl_0 `pseq` (kl_V2388 `pseq` eq appl_0 kl_V2388) case kl_if_1 of Atom (B (True)) -> do return (Atom Nil) Atom (B (False)) -> do !kl_if_2 <- let pat_cond_3 kl_V2388 kl_V2388h kl_V2388t = do !kl_if_4 <- let pat_cond_5 kl_V2388t kl_V2388th kl_V2388tt = do !kl_if_6 <- let pat_cond_7 kl_V2388tt kl_V2388tth kl_V2388ttt = do let !appl_8 = Atom Nil !kl_if_9 <- appl_8 `pseq` (kl_V2388ttt `pseq` eq appl_8 kl_V2388ttt) !kl_if_10 <- case kl_if_9 of Atom (B (True)) -> do let pat_cond_11 = do return (Atom (B True)) pat_cond_12 = do do return (Atom (B False)) in case kl_V2388th of kl_V2388th@(Atom (UnboundSym "bar!")) -> pat_cond_11 kl_V2388th@(ApplC (PL "bar!" _)) -> pat_cond_11 kl_V2388th@(ApplC (Func "bar!" _)) -> pat_cond_11 _ -> pat_cond_12 Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_10 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_13 = do do return (Atom (B False)) in case kl_V2388tt of !(kl_V2388tt@(Cons (!kl_V2388tth) (!kl_V2388ttt))) -> pat_cond_7 kl_V2388tt kl_V2388tth kl_V2388ttt _ -> pat_cond_13 case kl_if_6 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_14 = do do return (Atom (B False)) in case kl_V2388t of !(kl_V2388t@(Cons (!kl_V2388th) (!kl_V2388tt))) -> pat_cond_5 kl_V2388t kl_V2388th kl_V2388tt _ -> pat_cond_14 case kl_if_4 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_15 = do do return (Atom (B False)) in case kl_V2388 of !(kl_V2388@(Cons (!kl_V2388h) (!kl_V2388t))) -> pat_cond_3 kl_V2388 kl_V2388h kl_V2388t _ -> pat_cond_15 case kl_if_2 of Atom (B (True)) -> do !appl_16 <- kl_V2388 `pseq` hd kl_V2388 !appl_17 <- kl_V2388 `pseq` tl kl_V2388 !appl_18 <- appl_17 `pseq` tl appl_17 !appl_19 <- appl_16 `pseq` (appl_18 `pseq` klCons appl_16 appl_18) appl_19 `pseq` klCons (ApplC (wrapNamed "cons" klCons)) appl_19 Atom (B (False)) -> do let pat_cond_20 kl_V2388 kl_V2388h kl_V2388t = do !appl_21 <- kl_V2388t `pseq` kl_shen_cons_form kl_V2388t let !appl_22 = Atom Nil !appl_23 <- appl_21 `pseq` (appl_22 `pseq` klCons appl_21 appl_22) !appl_24 <- kl_V2388h `pseq` (appl_23 `pseq` klCons kl_V2388h appl_23) appl_24 `pseq` klCons (ApplC (wrapNamed "cons" klCons)) appl_24 pat_cond_25 = do do let !aw_26 = Core.Types.Atom (Core.Types.UnboundSym "shen.f_error") applyWrapper aw_26 [ApplC (wrapNamed "shen.cons_form" kl_shen_cons_form)] in case kl_V2388 of !(kl_V2388@(Cons (!kl_V2388h) (!kl_V2388t))) -> pat_cond_20 kl_V2388 kl_V2388h kl_V2388t _ -> pat_cond_25 _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" kl_shen_package_macro :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_package_macro (!kl_V2393) (!kl_V2394) = do !kl_if_0 <- let pat_cond_1 kl_V2393 kl_V2393h kl_V2393t = do !kl_if_2 <- let pat_cond_3 = do !kl_if_4 <- let pat_cond_5 kl_V2393t kl_V2393th kl_V2393tt = do let !appl_6 = Atom Nil !kl_if_7 <- appl_6 `pseq` (kl_V2393tt `pseq` eq appl_6 kl_V2393tt) case kl_if_7 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_8 = do do return (Atom (B False)) in case kl_V2393t of !(kl_V2393t@(Cons (!kl_V2393th) (!kl_V2393tt))) -> pat_cond_5 kl_V2393t kl_V2393th kl_V2393tt _ -> pat_cond_8 case kl_if_4 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_9 = do do return (Atom (B False)) in case kl_V2393h of kl_V2393h@(Atom (UnboundSym "$")) -> pat_cond_3 kl_V2393h@(ApplC (PL "$" _)) -> pat_cond_3 kl_V2393h@(ApplC (Func "$" _)) -> pat_cond_3 _ -> pat_cond_9 case kl_if_2 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" pat_cond_10 = do do return (Atom (B False)) in case kl_V2393 of !(kl_V2393@(Cons (!kl_V2393h) (!kl_V2393t))) -> pat_cond_1 kl_V2393 kl_V2393h kl_V2393t _ -> pat_cond_10 case kl_if_0 of Atom (B (True)) -> do !appl_11 <- kl_V2393 `pseq` tl kl_V2393 !appl_12 <- appl_11 `pseq` hd appl_11 !appl_13 <- appl_12 `pseq` kl_explode appl_12 appl_13 `pseq` (kl_V2394 `pseq` kl_append appl_13 kl_V2394) Atom (B (False)) -> do let pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt = do kl_V2393ttt `pseq` (kl_V2394 `pseq` kl_append kl_V2393ttt kl_V2394) pat_cond_15 kl_V2393 kl_V2393t kl_V2393th kl_V2393tt kl_V2393tth kl_V2393ttt = do let !appl_16 = ApplC (Func "lambda" (Context (\(!kl_ListofExceptions) -> do let !appl_17 = ApplC (Func "lambda" (Context (\(!kl_External) -> do let !appl_18 = ApplC (Func "lambda" (Context (\(!kl_PackageNameDot) -> do let !appl_19 = ApplC (Func "lambda" (Context (\(!kl_ExpPackageNameDot) -> do let !appl_20 = ApplC (Func "lambda" (Context (\(!kl_Packaged) -> do let !appl_21 = ApplC (Func "lambda" (Context (\(!kl_Internal) -> do kl_Packaged `pseq` (kl_V2394 `pseq` kl_append kl_Packaged kl_V2394)))) !appl_22 <- kl_ExpPackageNameDot `pseq` (kl_Packaged `pseq` kl_shen_internal_symbols kl_ExpPackageNameDot kl_Packaged) !appl_23 <- kl_V2393th `pseq` (appl_22 `pseq` kl_shen_record_internal kl_V2393th appl_22) appl_23 `pseq` applyWrapper appl_21 [appl_23]))) !appl_24 <- kl_PackageNameDot `pseq` (kl_ListofExceptions `pseq` (kl_V2393ttt `pseq` (kl_ExpPackageNameDot `pseq` kl_shen_packageh kl_PackageNameDot kl_ListofExceptions kl_V2393ttt kl_ExpPackageNameDot))) appl_24 `pseq` applyWrapper appl_20 [appl_24]))) !appl_25 <- kl_PackageNameDot `pseq` kl_explode kl_PackageNameDot appl_25 `pseq` applyWrapper appl_19 [appl_25]))) !appl_26 <- kl_V2393th `pseq` str kl_V2393th !appl_27 <- appl_26 `pseq` cn appl_26 (Core.Types.Atom (Core.Types.Str ".")) !appl_28 <- appl_27 `pseq` intern appl_27 appl_28 `pseq` applyWrapper appl_18 [appl_28]))) !appl_29 <- kl_ListofExceptions `pseq` (kl_V2393th `pseq` kl_shen_record_exceptions kl_ListofExceptions kl_V2393th) appl_29 `pseq` applyWrapper appl_17 [appl_29]))) !appl_30 <- kl_V2393tth `pseq` kl_shen_eval_without_macros kl_V2393tth appl_30 `pseq` applyWrapper appl_16 [appl_30] pat_cond_31 = do do kl_V2393 `pseq` (kl_V2394 `pseq` klCons kl_V2393 kl_V2394) in case kl_V2393 of !(kl_V2393@(Cons (Atom (UnboundSym "package")) (!(kl_V2393t@(Cons (Atom (UnboundSym "null")) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (Atom (UnboundSym "package")) (!(kl_V2393t@(Cons (ApplC (PL "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (Atom (UnboundSym "package")) (!(kl_V2393t@(Cons (ApplC (Func "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (PL "package" _)) (!(kl_V2393t@(Cons (Atom (UnboundSym "null")) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (PL "package" _)) (!(kl_V2393t@(Cons (ApplC (PL "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (PL "package" _)) (!(kl_V2393t@(Cons (ApplC (Func "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (Func "package" _)) (!(kl_V2393t@(Cons (Atom (UnboundSym "null")) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (Func "package" _)) (!(kl_V2393t@(Cons (ApplC (PL "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (Func "package" _)) (!(kl_V2393t@(Cons (ApplC (Func "null" _)) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_14 kl_V2393 kl_V2393t kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (Atom (UnboundSym "package")) (!(kl_V2393t@(Cons (!kl_V2393th) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_15 kl_V2393 kl_V2393t kl_V2393th kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (PL "package" _)) (!(kl_V2393t@(Cons (!kl_V2393th) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_15 kl_V2393 kl_V2393t kl_V2393th kl_V2393tt kl_V2393tth kl_V2393ttt !(kl_V2393@(Cons (ApplC (Func "package" _)) (!(kl_V2393t@(Cons (!kl_V2393th) (!(kl_V2393tt@(Cons (!kl_V2393tth) (!kl_V2393ttt))))))))) -> pat_cond_15 kl_V2393 kl_V2393t kl_V2393th kl_V2393tt kl_V2393tth kl_V2393ttt _ -> pat_cond_31 _ -> throwError "if: expected boolean" kl_shen_record_exceptions :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_record_exceptions (!kl_V2397) (!kl_V2398) = do let !appl_0 = ApplC (Func "lambda" (Context (\(!kl_CurrExceptions) -> do let !appl_1 = ApplC (Func "lambda" (Context (\(!kl_AllExceptions) -> do !appl_2 <- value (Core.Types.Atom (Core.Types.UnboundSym "*property-vector*")) kl_V2398 `pseq` (kl_AllExceptions `pseq` (appl_2 `pseq` kl_put kl_V2398 (Core.Types.Atom (Core.Types.UnboundSym "shen.external-symbols")) kl_AllExceptions appl_2))))) !appl_3 <- kl_V2397 `pseq` (kl_CurrExceptions `pseq` kl_union kl_V2397 kl_CurrExceptions) appl_3 `pseq` applyWrapper appl_1 [appl_3]))) let !appl_4 = ApplC (PL "thunk" (do return (Atom Nil))) !appl_5 <- value (Core.Types.Atom (Core.Types.UnboundSym "*property-vector*")) !appl_6 <- kl_V2398 `pseq` (appl_4 `pseq` (appl_5 `pseq` kl_getDivor kl_V2398 (Core.Types.Atom (Core.Types.UnboundSym "shen.external-symbols")) appl_4 appl_5)) appl_6 `pseq` applyWrapper appl_0 [appl_6] kl_shen_record_internal :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_record_internal (!kl_V2401) (!kl_V2402) = do let !appl_0 = ApplC (PL "thunk" (do return (Atom Nil))) !appl_1 <- value (Core.Types.Atom (Core.Types.UnboundSym "*property-vector*")) !appl_2 <- kl_V2401 `pseq` (appl_0 `pseq` (appl_1 `pseq` kl_getDivor kl_V2401 (ApplC (wrapNamed "shen.internal-symbols" kl_shen_internal_symbols)) appl_0 appl_1)) !appl_3 <- kl_V2402 `pseq` (appl_2 `pseq` kl_union kl_V2402 appl_2) !appl_4 <- value (Core.Types.Atom (Core.Types.UnboundSym "*property-vector*")) kl_V2401 `pseq` (appl_3 `pseq` (appl_4 `pseq` kl_put kl_V2401 (ApplC (wrapNamed "shen.internal-symbols" kl_shen_internal_symbols)) appl_3 appl_4)) kl_shen_internal_symbols :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_internal_symbols (!kl_V2413) (!kl_V2414) = do !kl_if_0 <- kl_V2414 `pseq` kl_symbolP kl_V2414 !kl_if_1 <- case kl_if_0 of Atom (B (True)) -> do !appl_2 <- kl_V2414 `pseq` kl_explode kl_V2414 !kl_if_3 <- kl_V2413 `pseq` (appl_2 `pseq` kl_shen_prefixP kl_V2413 appl_2) case kl_if_3 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_1 of Atom (B (True)) -> do let !appl_4 = Atom Nil kl_V2414 `pseq` (appl_4 `pseq` klCons kl_V2414 appl_4) Atom (B (False)) -> do let pat_cond_5 kl_V2414 kl_V2414h kl_V2414t = do !appl_6 <- kl_V2413 `pseq` (kl_V2414h `pseq` kl_shen_internal_symbols kl_V2413 kl_V2414h) !appl_7 <- kl_V2413 `pseq` (kl_V2414t `pseq` kl_shen_internal_symbols kl_V2413 kl_V2414t) appl_6 `pseq` (appl_7 `pseq` kl_union appl_6 appl_7) pat_cond_8 = do do return (Atom Nil) in case kl_V2414 of !(kl_V2414@(Cons (!kl_V2414h) (!kl_V2414t))) -> pat_cond_5 kl_V2414 kl_V2414h kl_V2414t _ -> pat_cond_8 _ -> throwError "if: expected boolean" kl_shen_packageh :: Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLValue -> Core.Types.KLContext Core.Types.Env Core.Types.KLValue kl_shen_packageh (!kl_V2431) (!kl_V2432) (!kl_V2433) (!kl_V2434) = do let pat_cond_0 kl_V2433 kl_V2433h kl_V2433t = do !appl_1 <- kl_V2431 `pseq` (kl_V2432 `pseq` (kl_V2433h `pseq` (kl_V2434 `pseq` kl_shen_packageh kl_V2431 kl_V2432 kl_V2433h kl_V2434))) !appl_2 <- kl_V2431 `pseq` (kl_V2432 `pseq` (kl_V2433t `pseq` (kl_V2434 `pseq` kl_shen_packageh kl_V2431 kl_V2432 kl_V2433t kl_V2434))) appl_1 `pseq` (appl_2 `pseq` klCons appl_1 appl_2) pat_cond_3 = do !kl_if_4 <- kl_V2433 `pseq` kl_shen_sysfuncP kl_V2433 !kl_if_5 <- case kl_if_4 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_6 <- kl_V2433 `pseq` kl_variableP kl_V2433 !kl_if_7 <- case kl_if_6 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_8 <- kl_V2433 `pseq` (kl_V2432 `pseq` kl_elementP kl_V2433 kl_V2432) !kl_if_9 <- case kl_if_8 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_10 <- kl_V2433 `pseq` kl_shen_doubleunderlineP kl_V2433 !kl_if_11 <- case kl_if_10 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do !kl_if_12 <- kl_V2433 `pseq` kl_shen_singleunderlineP kl_V2433 case kl_if_12 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_11 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_9 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_7 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" case kl_if_5 of Atom (B (True)) -> do return kl_V2433 Atom (B (False)) -> do !kl_if_13 <- kl_V2433 `pseq` kl_symbolP kl_V2433 !kl_if_14 <- case kl_if_13 of Atom (B (True)) -> do let !appl_15 = ApplC (Func "lambda" (Context (\(!kl_ExplodeX) -> do let !appl_16 = Atom Nil !appl_17 <- appl_16 `pseq` klCons (Core.Types.Atom (Core.Types.Str ".")) appl_16 !appl_18 <- appl_17 `pseq` klCons (Core.Types.Atom (Core.Types.Str "n")) appl_17 !appl_19 <- appl_18 `pseq` klCons (Core.Types.Atom (Core.Types.Str "e")) appl_18 !appl_20 <- appl_19 `pseq` klCons (Core.Types.Atom (Core.Types.Str "h")) appl_19 !appl_21 <- appl_20 `pseq` klCons (Core.Types.Atom (Core.Types.Str "s")) appl_20 !appl_22 <- appl_21 `pseq` (kl_ExplodeX `pseq` kl_shen_prefixP appl_21 kl_ExplodeX) !kl_if_23 <- appl_22 `pseq` kl_not appl_22 case kl_if_23 of Atom (B (True)) -> do !appl_24 <- kl_V2434 `pseq` (kl_ExplodeX `pseq` kl_shen_prefixP kl_V2434 kl_ExplodeX) !kl_if_25 <- appl_24 `pseq` kl_not appl_24 case kl_if_25 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean"))) !appl_26 <- kl_V2433 `pseq` kl_explode kl_V2433 !kl_if_27 <- appl_26 `pseq` applyWrapper appl_15 [appl_26] case kl_if_27 of Atom (B (True)) -> do return (Atom (B True)) Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" Atom (B (False)) -> do do return (Atom (B False)) _ -> throwError "if: expected boolean" case kl_if_14 of Atom (B (True)) -> do kl_V2431 `pseq` (kl_V2433 `pseq` kl_concat kl_V2431 kl_V2433) Atom (B (False)) -> do do return kl_V2433 _ -> throwError "if: expected boolean" _ -> throwError "if: expected boolean" in case kl_V2433 of !(kl_V2433@(Cons (!kl_V2433h) (!kl_V2433t))) -> pat_cond_0 kl_V2433 kl_V2433h kl_V2433t _ -> pat_cond_3 expr5 :: Core.Types.KLContext Core.Types.Env Core.Types.KLValue expr5 = do (do return (Core.Types.Atom (Core.Types.Str "Copyright (c) 2015, Mark Tarver\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n3. The name of Mark Tarver may not be used to endorse or promote products\n derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY Mark Tarver ''AS IS'' AND ANY\nEXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL Mark Tarver BE LIABLE FOR ANY\nDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\nON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."))) `catchError` (\(!kl_E) -> do return (Core.Types.Atom (Core.Types.Str "E")))