diff --git a/.gitignore b/.gitignore index 5519fc3c..c41cc9e3 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1 @@ -/target -*.flat \ No newline at end of file +/target \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index 1557548c..9878501e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,12 +3,12 @@ version = 3 [[package]] -name = "ahash" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217" +name = "aiken" +version = "0.0.1" dependencies = [ - "const-random", + "anyhow", + "clap", + "uplc", ] [[package]] @@ -40,21 +40,6 @@ version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chumsky" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d02796e4586c6c41aeb68eae9bfb4558a522c35f1430c14b40136c3706e09e4" -dependencies = [ - "ahash", -] - [[package]] name = "clap" version = "3.1.18" @@ -94,53 +79,14 @@ dependencies = [ "os_str_bytes", ] -[[package]] -name = "const-random" -version = "0.1.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f590d95d011aa80b063ffe3253422ed5aa462af4e9867d43ce8337562bac77c4" -dependencies = [ - "const-random-macro", - "proc-macro-hack", -] - -[[package]] -name = "const-random-macro" -version = "0.1.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "615f6e27d000a2bffbc7f2f6a8669179378fa27ee4d0a509e985dfc0a7defb40" -dependencies = [ - "getrandom", - "lazy_static", - "proc-macro-hack", - "tiny-keccak", -] - -[[package]] -name = "crunchy" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" - [[package]] name = "flat" -version = "0.0.0" +version = "0.0.1" dependencies = [ "anyhow", "thiserror", ] -[[package]] -name = "getrandom" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad" -dependencies = [ - "cfg-if", - "libc", - "wasi", -] - [[package]] name = "hashbrown" version = "0.11.2" @@ -190,15 +136,6 @@ version = "0.2.126" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "349d5a591cd28b49e1d1037471617a32ddcda5731b99419008085f72d5a53836" -[[package]] -name = "neptune" -version = "0.0.0" -dependencies = [ - "anyhow", - "clap", - "uplc", -] - [[package]] name = "os_str_bytes" version = "6.0.1" @@ -256,12 +193,6 @@ dependencies = [ "version_check", ] -[[package]] -name = "proc-macro-hack" -version = "0.5.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" - [[package]] name = "proc-macro2" version = "1.0.39" @@ -357,15 +288,6 @@ dependencies = [ "syn", ] -[[package]] -name = "tiny-keccak" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" -dependencies = [ - "crunchy", -] - [[package]] name = "unicode-ident" version = "1.0.0" @@ -374,9 +296,8 @@ checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee" [[package]] name = "uplc" -version = "0.1.0" +version = "0.0.1" dependencies = [ - "chumsky", "flat", "hex", "peg", @@ -391,12 +312,6 @@ version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" -[[package]] -name = "wasi" -version = "0.10.2+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6" - [[package]] name = "winapi" version = "0.3.9" diff --git a/README.md b/README.md index f143414c..f8fd4cc4 100644 --- a/README.md +++ b/README.md @@ -1,22 +1,23 @@ -# Neptune +# AIKEN -Experiments with Plutus Core +A cardano smart contract language and toolchain ## Roadmap These are generic milestones and the listed ordering -is not necessariy the implementation order +is not necessariy the implementation order or full scope. -- [ ] compile plutus core into it's on chain encoding -- [ ] reverse the on chain encoding into plutus core +- [x] compile plutus core into it's on chain encoding +- [x] reverse the on chain encoding into plutus core +- [ ] Plutus Core interpreter - [ ] create a higher level syntax with inspiration from - JS - ReasonML - Elm - Roc - Rust + - Gleam - [ ] Language Server -- [ ] Plutus Core interpreter ## Resources diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 996ced22..1246c325 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -1,6 +1,6 @@ [package] -name = "neptune" -version = "0.0.0" +name = "aiken" +version = "0.0.1" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs index 9c3341b3..72b81c0b 100644 --- a/crates/cli/src/lib.rs +++ b/crates/cli/src/lib.rs @@ -12,8 +12,16 @@ pub enum Cli { #[derive(Subcommand)] pub enum UplcCommand { - Flat { input: PathBuf }, - Unflat { input: PathBuf }, + Flat { + input: PathBuf, + #[clap(short, long)] + print: bool, + }, + Unflat { + input: PathBuf, + #[clap(short, long)] + print: bool, + }, } impl Default for Cli { diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 634ff773..7ae58c24 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -3,14 +3,14 @@ use uplc::{ parser, }; -use neptune::{Cli, UplcCommand}; +use aiken::{Cli, UplcCommand}; fn main() -> anyhow::Result<()> { let args = Cli::default(); match args { Cli::Uplc(uplc) => match uplc { - UplcCommand::Flat { input } => { + UplcCommand::Flat { input, print } => { let code = std::fs::read_to_string(&input)?; let program = parser::program(&code)?; @@ -19,26 +19,28 @@ fn main() -> anyhow::Result<()> { let bytes = program.to_flat()?; - for (i, byte) in bytes.iter().enumerate() { - print!("{:08b}", byte); + if print { + for (i, byte) in bytes.iter().enumerate() { + print!("{:08b}", byte); - if (i + 1) % 4 == 0 { - println!(); - } else { - print!(" "); + if (i + 1) % 4 == 0 { + println!(); + } else { + print!(" "); + } } - } - println!(); + println!(); + } } - UplcCommand::Unflat { input } => { + UplcCommand::Unflat { input, print } => { let bytes = std::fs::read(&input)?; let program = Program::::from_flat(&bytes)?; - let encoded_flat = program.to_flat()?; - println!("{}", encoded_flat.len()); - assert!(bytes == encoded_flat) + if print { + println!("{:#?}", program); + } } }, } diff --git a/crates/flat/Cargo.toml b/crates/flat/Cargo.toml index 1720ee99..6c5d97bc 100644 --- a/crates/flat/Cargo.toml +++ b/crates/flat/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "flat" -version = "0.0.0" +version = "0.0.1" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/crates/uplc/Cargo.toml b/crates/uplc/Cargo.toml index 890e2223..d0fe56c7 100644 --- a/crates/uplc/Cargo.toml +++ b/crates/uplc/Cargo.toml @@ -1,12 +1,11 @@ [package] name = "uplc" -version = "0.1.0" +version = "0.0.1" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -chumsky = "0.8.0" flat = { path = "../flat" } hex = "0.4.3" peg = "0.8.0" diff --git a/crates/uplc/example/integer.uplc b/crates/uplc/example/integer.uplc deleted file mode 100644 index 4b44183c..00000000 --- a/crates/uplc/example/integer.uplc +++ /dev/null @@ -1,7 +0,0 @@ -(program 11.22.33 - [ - ( - lam x (lam x x)) (con string "PT8" - ) - ] -) \ No newline at end of file diff --git a/crates/uplc/src/lib.rs b/crates/uplc/src/lib.rs index 9afe7885..5dc3c5d4 100644 --- a/crates/uplc/src/lib.rs +++ b/crates/uplc/src/lib.rs @@ -1,7 +1,8 @@ -#![recursion_limit = "10000"] - pub mod ast; pub mod builtins; mod debruijn; mod flat; pub mod parser; + +#[cfg(test)] +mod test; diff --git a/crates/uplc/src/parser.rs b/crates/uplc/src/parser.rs index a7c0697d..fc91a2b9 100644 --- a/crates/uplc/src/parser.rs +++ b/crates/uplc/src/parser.rs @@ -1,20 +1,31 @@ -use std::{collections::HashMap, str::FromStr}; - -use chumsky::{ - prelude::{end, filter, just, recursive, Simple}, - text::{ident, int, keyword, TextParser}, - Parser, -}; +use std::str::FromStr; use crate::{ - ast::{Constant, Name, Program, Term, Unique}, + ast::{Constant, Name, Program, Term}, builtins::DefaultFunction, }; +use interner::Interner; +use peg::{error::ParseError, str::LineCol}; + +mod interner; + +pub fn program(src: &str) -> Result, ParseError> { + let mut interner = Interner::new(); + + let mut program = uplc::program(src)?; + + interner.program(&mut program); + + Ok(program) +} + peg::parser! { - grammar parser() for str { + grammar uplc() for str { pub rule program() -> Program - = "(" _* "program" _+ v:version() _+ t:term() _* ")" { Program {version: v, term: t} } + = _* "(" _* "program" _+ v:version() _+ t:term() _* ")" _* { + Program {version: v, term: t} + } rule version() -> (usize, usize, usize) = major:number() "." minor:number() "." patch:number() { @@ -43,7 +54,9 @@ peg::parser! { } rule builtin() -> Term - = "(" _* "builtin" _+ b:ident() _* ")" { Term::Builtin(DefaultFunction::from_str(&b).unwrap()) } + = "(" _* "builtin" _+ b:ident() _* ")" { + Term::Builtin(DefaultFunction::from_str(&b).unwrap()) + } rule var() -> Term = n:name() { Term::Var(n) } @@ -77,7 +90,9 @@ peg::parser! { = "integer" _+ i:number() { Constant::Integer(i as isize) } rule constant_bytestring() -> Constant - = "bytestring" _+ "#" i:ident()* { Constant::ByteString(hex::decode(String::from_iter(i)).unwrap()) } + = "bytestring" _+ "#" i:ident()* { + Constant::ByteString(hex::decode(String::from_iter(i)).unwrap()) + } rule constant_string() -> Constant = "string" _+ "\"" s:[^ '"']* "\"" { Constant::String(String::from_iter(s)) } @@ -94,195 +109,19 @@ peg::parser! { rule name() -> Name = text:ident() { Name { text, unique: 0.into() } } - rule ident() -> String = i:['a'..='z' | 'A'..='Z' | '0'..='9' | '_']+ { String::from_iter(i) } + rule ident() -> String + = i:['a'..='z' | 'A'..='Z' | '0'..='9' | '_']+ { + String::from_iter(i) + } rule _ = [' ' | '\n'] } } -struct ParserState { - identifiers: HashMap, - current: Unique, -} - -impl ParserState { - fn new() -> Self { - ParserState { - identifiers: HashMap::new(), - current: Unique::new(0), - } - } - - fn intern(&mut self, text: &str) -> Unique { - if let Some(u) = self.identifiers.get(text) { - *u - } else { - let unique = self.current; - - self.identifiers.insert(text.to_string(), unique); - - self.current.increment(); - - unique - } - } -} - -pub fn program(src: &str) -> Result, peg::error::ParseError> { - parser::program(src) -} - -fn program_() -> impl Parser, Error = Simple> { - keyword("program") - .ignore_then(version().padded()) - .then(term()) - .map(|(version, term)| Program { version, term }) - .delimited_by(just('(').padded(), just(')').padded()) - .then_ignore(end()) -} - -fn version() -> impl Parser> { - int(10) - .then_ignore(just('.')) - .then(int(10)) - .then_ignore(just('.')) - .then(int(10)) - .map(|((major, minor), patch)| { - ( - major.parse::().unwrap(), - minor.parse::().unwrap(), - patch.parse::().unwrap(), - ) - }) -} - -fn term() -> impl Parser, Error = Simple> { - recursive(|term| { - let delay = keyword("delay") - .ignore_then(term.clone().padded()) - .delimited_by(just('(').padded(), just(')').padded()) - .map(|t| dbg!(Term::Delay(Box::new(t)))); - - let force = keyword("force") - .ignore_then(term.clone().padded()) - .delimited_by(just('(').padded(), just(')').padded()) - .map(|t| dbg!(Term::Force(Box::new(t)))); - - let lambda = keyword("lam") - .ignore_then(name().padded()) - .then(term.clone()) - .delimited_by(just('(').padded(), just(')').padded()) - .map(|(parameter_name, t)| { - dbg!(Term::Lambda { - parameter_name, - body: Box::new(t), - }) - }); - - let apply = term - .clone() - .padded() - .then(term.clone().padded().repeated()) - .delimited_by(just('[').padded(), just(']').padded()) - .foldl(|lhs, rhs| Term::Apply { - function: Box::new(lhs), - argument: Box::new(rhs), - }); - - constant() - .or(builtin()) - .or(var()) - .or(lambda) - .or(apply) - .or(delay) - .or(force) - .or(error()) - }) -} - -fn constant() -> impl Parser, Error = Simple> { - keyword("con") - .ignore_then( - constant_integer() - .or(constant_bytestring()) - .or(constant_string()) - .or(constant_unit()) - .or(constant_bool()), - ) - .delimited_by(just('(').padded(), just(')').padded()) - .map(Term::Constant) -} - -fn builtin() -> impl Parser, Error = Simple> { - keyword("builtin") - .ignore_then(ident().padded()) - .delimited_by(just('(').padded(), just(')').padded()) - .map(|builtin_name: String| { - Term::Builtin(DefaultFunction::from_str(&builtin_name).unwrap()) - }) -} - -fn var() -> impl Parser, Error = Simple> { - name().map(Term::Var) -} - -fn error() -> impl Parser, Error = Simple> { - keyword("error") - .ignored() - .delimited_by(just('(').padded(), just(')').padded()) - .map(|_| Term::Error) -} - -fn name() -> impl Parser> { - ident().map(|text| Name { - text, - unique: 0.into(), - }) -} - -fn constant_integer() -> impl Parser> { - keyword("integer") - .padded() - .ignore_then(int(10)) - .map(|d: String| Constant::Integer(d.parse::().unwrap())) -} - -fn constant_bytestring() -> impl Parser> { - keyword("bytestring") - .padded() - .ignore_then(just('#')) - .ignore_then(int(16)) - .map(|b: String| Constant::ByteString(hex::decode(b).unwrap())) -} - -fn constant_string() -> impl Parser> { - keyword("string") - .padded() - .ignore_then(just('"')) - .ignore_then(filter(|c| *c != '"').repeated()) - .then_ignore(just('"')) - .collect::() - .map(Constant::String) -} - -fn constant_unit() -> impl Parser> { - keyword("unit") - .padded() - .ignore_then(just('(')) - .ignore_then(just(')')) - .ignored() - .map(|_| Constant::Unit) -} - -fn constant_bool() -> impl Parser> { - keyword("bool") - .padded() - .ignore_then(just("True").or(just("False"))) - .map(|b| Constant::Bool(b == "True")) -} - #[cfg(test)] mod test { + use crate::ast::{Constant, Name, Program, Term}; + #[test] fn parse_program() { let code = r#" @@ -290,12 +129,14 @@ mod test { (con integer 11) ) "#; - let result = super::program(code); + let program = super::program(code).unwrap(); - assert!(result.is_ok()); - - let program = result.unwrap(); - - assert_eq!(program.version, (11, 22, 33)); + assert_eq!( + program, + Program:: { + version: (11, 22, 33), + term: Term::Constant(Constant::Integer(11)), + } + ); } } diff --git a/crates/uplc/src/parser/interner.rs b/crates/uplc/src/parser/interner.rs new file mode 100644 index 00000000..ceae93aa --- /dev/null +++ b/crates/uplc/src/parser/interner.rs @@ -0,0 +1,57 @@ +use std::collections::HashMap; + +use crate::ast::{Name, Program, Term, Unique}; + +pub struct Interner { + identifiers: HashMap, + current: Unique, +} + +impl Interner { + pub fn new() -> Self { + Interner { + identifiers: HashMap::new(), + current: Unique::new(0), + } + } + + pub fn program(&mut self, program: &mut Program) { + self.term(&mut program.term); + } + + pub fn term(&mut self, term: &mut Term) { + match term { + Term::Var(name) => name.unique = self.intern(&name.text), + Term::Delay(term) => self.term(term), + Term::Lambda { + parameter_name, + body, + } => { + parameter_name.unique = self.intern(¶meter_name.text); + self.term(body); + } + Term::Apply { function, argument } => { + self.term(function); + self.term(argument); + } + Term::Constant(_) => (), + Term::Force(term) => self.term(term), + Term::Error => (), + Term::Builtin(_) => (), + } + } + + fn intern(&mut self, text: &str) -> Unique { + if let Some(u) = self.identifiers.get(text) { + *u + } else { + let unique = self.current; + + self.identifiers.insert(text.to_string(), unique); + + self.current.increment(); + + unique + } + } +} diff --git a/crates/uplc/src/test.rs b/crates/uplc/src/test.rs new file mode 100644 index 00000000..1417877b --- /dev/null +++ b/crates/uplc/src/test.rs @@ -0,0 +1,41 @@ +// e2e encoding/decoding tests +use crate::{ + ast::{DeBruijn, Program}, + parser, +}; + +#[test] +fn integer() { + let bytes = include_bytes!("../test_data/basic/integer/integer.flat"); + let code = include_str!("../test_data/basic/integer/integer.uplc"); + + let parsed_program = parser::program(code).unwrap(); + + let debruijn_program: Program = parsed_program.try_into().unwrap(); + + let decoded_program: Program = Program::from_flat(bytes).unwrap(); + + assert_eq!(debruijn_program, decoded_program); + + let encoded_program = debruijn_program.to_flat().unwrap(); + + assert_eq!(encoded_program, bytes); +} + +#[test] +fn jpg() { + let bytes = include_bytes!("../test_data/jpg/jpg.flat"); + let code = include_str!("../test_data/jpg/jpg.uplc"); + + let parsed_program = parser::program(code).unwrap(); + + let debruijn_program: Program = parsed_program.try_into().unwrap(); + + let decoded_program: Program = Program::from_flat(bytes).unwrap(); + + assert_eq!(debruijn_program, decoded_program); + + let encoded_program = debruijn_program.to_flat().unwrap(); + + assert_eq!(encoded_program, bytes); +} diff --git a/crates/uplc/test_data/basic/integer/integer.flat b/crates/uplc/test_data/basic/integer/integer.flat new file mode 100644 index 00000000..885d8f06 --- /dev/null +++ b/crates/uplc/test_data/basic/integer/integer.flat @@ -0,0 +1 @@ + !H \ No newline at end of file diff --git a/crates/uplc/test_data/basic/integer/integer.uplc b/crates/uplc/test_data/basic/integer/integer.uplc new file mode 100644 index 00000000..7e4c5e38 --- /dev/null +++ b/crates/uplc/test_data/basic/integer/integer.uplc @@ -0,0 +1,3 @@ +(program 11.22.33 + (con integer 11) +) \ No newline at end of file diff --git a/crates/uplc/test_data/jpg/jpg.flat b/crates/uplc/test_data/jpg/jpg.flat new file mode 100644 index 00000000..9e836ef4 Binary files /dev/null and b/crates/uplc/test_data/jpg/jpg.flat differ diff --git a/crates/uplc/test_data/jpg/jpg.uplc b/crates/uplc/test_data/jpg/jpg.uplc new file mode 100644 index 00000000..17e86c22 --- /dev/null +++ b/crates/uplc/test_data/jpg/jpg.uplc @@ -0,0 +1,9724 @@ +(program + 1.0.0 + [ + (lam + i_0 + [ + [ + (lam + i_1 + (lam + i_2 + [ + (lam + i_3 + [ + (lam + i_4 + [ + (lam + i_5 + [ + [ + (lam + i_6 + (lam + i_7 + [ + [ + [ + (lam + i_8 + (lam + i_9 + (lam + i_10 + [ + (lam + i_11 + [ + (lam + i_12 + [ + [ + [ + (lam + i_13 + (lam + i_14 + (lam + i_15 + [ + (lam + i_16 + [ + [ + [ + (lam + i_17 + (lam + i_18 + (lam + i_19 + [ + (lam + i_20 + [ + [ + [ + (lam + i_21 + (lam + i_22 + (lam + i_23 + [ + [ + (lam + i_24 + (lam + i_25 + [ + (lam + i_26 + [ + [ + (lam + i_27 + (lam + i_28 + [ + (lam + i_29 + [ + [ + [ + (lam + i_30 + (lam + i_31 + (lam + i_32 + [ + (lam + i_33 + [ + (lam + i_34 + [ + [ + (lam + i_35 + (lam + i_36 + [ + [ + (lam + i_37 + (lam + i_38 + [ + (lam + i_39 + [ + (lam + i_40 + [ + [ + (lam + i_41 + (lam + i_42 + [ + (lam + i_43 + [ + (lam + i_44 + [ + [ + [ + (lam + i_45 + (lam + i_46 + (lam + i_47 + [ + [ + (lam + i_48 + (lam + i_49 + [ + [ + (lam + i_50 + (lam + i_51 + [ + [ + (lam + i_52 + (lam + i_53 + [ + [ + (lam + i_54 + (lam + i_55 + [ + (lam + i_56 + [ + (lam + i_57 + [ + (lam + i_58 + [ + (lam + i_59 + [ + (lam + i_60 + [ + (lam + i_61 + [ + (lam + i_62 + [ + (lam + i_63 + [ + (lam + i_64 + [ + (lam + i_65 + [ + (lam + i_66 + [ + (lam + i_67 + [ + [ + (lam + i_68 + (lam + i_69 + [ + (lam + i_70 + [ + (lam + i_71 + [ + (lam + i_72 + [ + (lam + i_73 + [ + (lam + i_74 + [ + (lam + i_75 + [ + (lam + i_76 + [ + (lam + i_77 + [ + [ + (lam + i_78 + (lam + i_79 + [ + (lam + i_80 + [ + (lam + i_81 + [ + (lam + i_82 + [ + [ + (lam + i_83 + (lam + i_84 + [ + (lam + i_85 + [ + [ + [ + [ + (lam + i_86 + (lam + i_87 + (lam + i_88 + (lam + i_89 + [ + (lam + i_90 + [ + (lam + i_91 + [ + (lam + i_92 + [ + (lam + i_93 + [ + (lam + i_94 + [ + (lam + i_95 + (lam + i_96 + (lam + i_97 + [ + (lam + i_98 + (lam + i_99 + [ + (lam + i_100 + [ + (lam + i_101 + (force + [ + [ + (force + [ + i_10 + [ + [ + (lam + i_102 + (lam + i_103 + [ + (force + [ + i_55 + i_103 + ] + ) + (lam + i_104 + (lam + i_105 + [ + (force + [ + i_53 + i_104 + ] + ) + (lam + i_106 + (lam + i_107 + (lam + i_108 + (lam + i_109 + (lam + i_110 + (lam + i_111 + (lam + i_112 + (lam + i_113 + [ + (lam + i_114 + (lam + i_115 + (lam + i_116 + [ + (force + [ + i_49 + i_105 + ] + ) + (lam + i_117 + [ + (lam + i_118 + [ + (lam + i_119 + [ + (lam + i_120 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (lam + i_121 + (lam + i_122 + (lam + i_123 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_121 + i_122 + ] + i_123 + ] + ] + ) + (delay + i_9 + ) + ] + (delay + i_8 + ) + ] + ) + ) + ) + ) + (force + i_11 + ) + ] + [ + (lam + i_124 + [ + (force + [ + i_51 + i_124 + ] + ) + (lam + i_125 + (lam + i_126 + i_125 + ) + ) + ] + ) + [ + (lam + i_127 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_127 + ] + ) + (delay + [ + (force + i_4 + ) + (con + string + "PT8" + ) + ] + ) + ] + (lam + i_128 + (lam + i_129 + (delay + i_128 + ) + ) + ) + ] + ) + ) + [ + i_75 + (force + i_119 + ) + ] + ] + ] + ] + i_117 + ] + ] + ) + (delay + i_8 + ) + ] + (delay + (force + [ + [ + (force + [ + i_47 + i_102 + ] + ) + (delay + [ + [ + i_94 + (con + string + "5" + ) + ] + [ + [ + [ + (force + (force + i_80 + ) + ) + [ + i_74 + (delay + (lam + i_130 + i_130 + ) + ) + ] + ] + (lam + i_131 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_131 + ] + ) + (lam + i_132 + (lam + i_133 + [ + (lam + i_134 + [ + [ + (force + (force + i_77 + ) + ) + [ + [ + (force + (force + i_80 + ) + ) + [ + i_74 + (delay + (lam + i_135 + i_135 + ) + ) + ] + ] + (lam + i_136 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_136 + ] + ) + (lam + i_137 + (lam + i_138 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_138 + ] + ) + (lam + i_139 + (lam + i_140 + (force + [ + [ + (force + [ + (force + i_19 + ) + [ + [ + (force + (force + i_77 + ) + ) + [ + [ + (force + (force + i_93 + ) + ) + i_57 + ] + i_137 + ] + ] + i_134 + ] + ] + ) + (lam + i_141 + (delay + (force + [ + [ + (force + [ + (force + i_19 + ) + [ + [ + (force + (force + i_77 + ) + ) + [ + [ + [ + (force + (force + (force + i_81 + ) + ) + ) + [ + i_74 + (delay + (lam + i_142 + i_142 + ) + ) + ] + ] + (lam + i_143 + (lam + i_144 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_143 + ] + ) + (lam + i_145 + [ + (lam + i_146 + (lam + i_147 + [ + [ + (lam + i_148 + (lam + i_149 + (force + [ + [ + (force + [ + (force + i_19 + ) + i_148 + ] + ) + (lam + i_150 + (delay + [ + i_149 + i_150 + ] + ) + ) + ] + (delay + (force + i_18 + ) + ) + ] + ) + ) + ) + i_144 + ] + (lam + i_151 + (force + [ + [ + (force + [ + (force + i_19 + ) + [ + [ + [ + (force + (force + i_93 + ) + ) + i_57 + ] + i_145 + ] + i_141 + ] + ] + ) + (lam + i_152 + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + i_61 + i_152 + ] + i_147 + ] + ] + ) + (delay + [ + [ + (force + (force + i_77 + ) + ) + (force + i_17 + ) + ] + [ + i_146 + i_151 + ] + ] + ) + ] + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + i_39 + i_152 + ] + i_147 + ] + ] + ) + (delay + [ + [ + (force + (force + i_77 + ) + ) + (force + i_17 + ) + ] + [ + [ + [ + [ + (force + (force + i_92 + ) + ) + i_57 + ] + i_145 + ] + [ + [ + i_65 + i_152 + ] + i_147 + ] + ] + i_151 + ] + ] + ) + ] + (delay + (force + i_18 + ) + ) + ] + ) + ) + ] + ) + ) + ) + ] + (delay + (force + i_18 + ) + ) + ] + ) + ) + ] + ) + ) + [ + (lam + i_153 + i_153 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_154 + (lam + i_155 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_155 + ] + ) + (delay + (force + i_30 + ) + ) + ] + (lam + i_156 + (lam + i_157 + (delay + [ + (force + [ + (force + (force + i_28 + ) + ) + i_156 + ] + ) + (lam + i_158 + (lam + i_159 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_57 + i_158 + ] + i_145 + ] + ] + ) + (delay + i_157 + ) + ] + (delay + [ + [ + (force + i_31 + ) + [ + [ + (force + (force + i_27 + ) + ) + i_158 + ] + i_159 + ] + ] + [ + i_154 + i_157 + ] + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ] + ) + ) + ] + [ + (force + i_17 + ) + i_141 + ] + ] + ] + i_140 + ] + ] + ) + (lam + i_160 + (delay + [ + [ + i_94 + (con + string + "10" + ) + ] + [ + [ + (lam + i_161 + (lam + i_162 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanInteger + ) + i_161 + ] + i_162 + ] + ] + i_9 + ] + i_8 + ] + ) + ) + [ + [ + (lam + i_163 + [ + [ + (force + (force + [ + i_74 + (delay + (lam + i_164 + i_164 + ) + ) + ] + ) + ) + [ + (force + i_85 + ) + i_163 + ] + ] + (lam + i_165 + i_165 + ) + ] + ) + [ + [ + (force + i_83 + ) + i_95 + ] + (con + integer + 0 + ) + ] + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_166 + i_166 + ) + ) + ] + ) + ) + (lam + i_167 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_167 + ] + ) + (lam + i_168 + (lam + i_169 + i_169 + ) + ) + ] + ) + ] + i_160 + ] + ] + ] + i_139 + ] + ] + ) + ) + ] + (delay + [ + [ + (force + (builtin + trace + ) + ) + (con + string + "11" + ) + ] + i_9 + ] + ) + ] + ) + ) + ) + ] + (delay + [ + [ + (force + (builtin + trace + ) + ) + (con + string + "12" + ) + ] + i_9 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ] + ) + ] + ] + i_133 + ] + ) + [ + [ + (lam + i_170 + [ + [ + (force + (force + [ + i_90 + (delay + (lam + i_171 + i_171 + ) + ) + ] + ) + ) + [ + (force + i_72 + ) + i_170 + ] + ] + [ + (force + i_73 + ) + i_170 + ] + ] + ) + [ + [ + (force + i_68 + ) + (lam + i_172 + (lam + i_173 + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_174 + i_174 + ) + ) + ] + ) + ) + (lam + i_175 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_175 + ] + ) + (lam + i_176 + (lam + i_177 + [ + [ + (force + (force + i_27 + ) + ) + i_176 + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_178 + i_178 + ) + ) + ] + ) + ) + (lam + i_179 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_179 + ] + ) + (lam + i_180 + (lam + i_181 + [ + [ + (force + (force + i_27 + ) + ) + i_180 + ] + [ + [ + [ + (force + [ + (force + (force + i_89 + ) + ) + i_181 + ] + ) + (lam + i_182 + [ + [ + i_95 + (con + integer + 0 + ) + ] + i_182 + ] + ) + ] + (lam + i_183 + (lam + i_184 + [ + [ + i_95 + i_183 + ] + i_184 + ] + ) + ) + ] + (lam + i_185 + [ + [ + i_95 + i_185 + ] + (con + integer + 0 + ) + ] + ) + ] + ] + ) + ) + ] + ) + ] + i_177 + ] + ] + ) + ) + ] + ) + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_186 + i_186 + ) + ) + ] + ) + ) + (lam + i_187 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_187 + ] + ) + (lam + i_188 + (lam + i_189 + [ + [ + (force + (force + i_27 + ) + ) + i_188 + ] + [ + [ + [ + (force + [ + (force + (force + i_89 + ) + ) + i_189 + ] + ) + (lam + i_190 + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_191 + i_191 + ) + ) + ] + ) + ) + (lam + i_192 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_192 + ] + ) + (lam + i_193 + (lam + i_194 + [ + [ + (force + (force + i_27 + ) + ) + i_193 + ] + [ + (force + (force + i_86 + ) + ) + i_194 + ] + ] + ) + ) + ] + ) + ] + i_190 + ] + ) + ] + (lam + i_195 + (lam + i_196 + [ + [ + [ + (force + (force + (force + i_91 + ) + ) + ) + i_57 + ] + i_195 + ] + i_196 + ] + ) + ) + ] + (lam + i_197 + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_198 + i_198 + ) + ) + ] + ) + ) + (lam + i_199 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_199 + ] + ) + (lam + i_200 + (lam + i_201 + [ + [ + (force + (force + i_27 + ) + ) + i_200 + ] + [ + (force + (force + i_88 + ) + ) + i_201 + ] + ] + ) + ) + ] + ) + ] + i_197 + ] + ) + ] + ] + ) + ) + ] + ) + ] + [ + [ + [ + (force + (force + (force + i_91 + ) + ) + ) + i_57 + ] + i_172 + ] + i_173 + ] + ] + ] + ) + ) + ] + (force + i_30 + ) + ] + ] + [ + [ + (lam + i_202 + [ + [ + (force + (force + [ + i_90 + (delay + (lam + i_203 + i_203 + ) + ) + ] + ) + ) + (lam + i_204 + (lam + i_205 + (force + [ + [ + (force + [ + (force + i_19 + ) + [ + i_202 + i_204 + ] + ] + ) + (lam + i_206 + (delay + [ + [ + (force + i_31 + ) + i_206 + ] + i_205 + ] + ) + ) + ] + (delay + i_205 + ) + ] + ) + ) + ) + ] + (force + i_30 + ) + ] + ) + (lam + i_207 + [ + (force + [ + i_42 + i_207 + ] + ) + (lam + i_208 + (lam + i_209 + (lam + i_210 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (lam + i_211 + i_211 + ) + (force + i_63 + ) + ] + i_132 + ] + i_208 + ] + ] + ) + (delay + [ + (force + i_17 + ) + i_209 + ] + ) + ] + (delay + (force + i_18 + ) + ) + ] + ) + ) + ) + ) + ] + ) + ] + i_107 + ] + ] + ] + ) + ) + ] + ) + ] + [ + (lam + i_212 + i_212 + ) + [ + [ + [ + [ + (force + (force + (force + i_81 + ) + ) + ) + [ + i_74 + (delay + (lam + i_213 + i_213 + ) + ) + ] + ] + (lam + i_214 + (lam + i_215 + [ + (force + [ + i_38 + i_214 + ] + ) + (lam + i_216 + (lam + i_217 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_57 + i_216 + ] + (force + i_114 + ) + ] + ] + ) + (delay + i_215 + ) + ] + (delay + [ + [ + [ + [ + (force + (force + (force + i_81 + ) + ) + ) + [ + i_74 + (delay + (lam + i_218 + i_218 + ) + ) + ] + ] + (lam + i_219 + [ + (force + [ + i_36 + i_219 + ] + ) + (lam + i_220 + (lam + i_221 + (lam + i_222 + (force + [ + [ + (force + [ + (force + i_19 + ) + [ + [ + [ + (force + (force + i_93 + ) + ) + (force + i_63 + ) + ] + i_220 + ] + i_222 + ] + ] + ) + (lam + i_223 + (delay + [ + [ + [ + [ + (force + (force + i_92 + ) + ) + (force + i_63 + ) + ] + i_220 + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_224 + i_224 + ) + ) + ] + ) + ) + (lam + i_225 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_225 + ] + ) + (lam + i_226 + (lam + i_227 + [ + [ + (force + (force + i_27 + ) + ) + i_226 + ] + [ + [ + [ + (force + [ + (force + (force + i_89 + ) + ) + i_227 + ] + ) + (lam + i_228 + i_228 + ) + ] + (lam + i_229 + (lam + i_230 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_229 + ] + ) + (lam + i_231 + (lam + i_232 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_230 + ] + ) + (lam + i_233 + (lam + i_234 + [ + [ + (force + (force + i_27 + ) + ) + [ + [ + i_95 + i_231 + ] + i_233 + ] + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_235 + i_235 + ) + ) + ] + ) + ) + (lam + i_236 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_236 + ] + ) + (lam + i_237 + (lam + i_238 + [ + [ + (force + (force + i_27 + ) + ) + i_237 + ] + [ + [ + [ + (force + [ + (force + (force + i_89 + ) + ) + i_238 + ] + ) + (lam + i_239 + i_239 + ) + ] + (lam + i_240 + (lam + i_241 + [ + [ + i_95 + i_240 + ] + i_241 + ] + ) + ) + ] + (lam + i_242 + i_242 + ) + ] + ] + ) + ) + ] + ) + ] + [ + [ + [ + (force + (force + (force + i_91 + ) + ) + ) + i_57 + ] + i_232 + ] + i_234 + ] + ] + ] + ) + ) + ] + ) + ) + ] + ) + ) + ] + (lam + i_243 + i_243 + ) + ] + ] + ) + ) + ] + ) + ] + [ + [ + [ + (force + (force + (force + i_91 + ) + ) + ) + i_57 + ] + i_221 + ] + i_223 + ] + ] + ] + i_222 + ] + ) + ) + ] + (delay + [ + [ + [ + [ + (force + (force + i_92 + ) + ) + (force + i_63 + ) + ] + i_220 + ] + i_221 + ] + i_222 + ] + ) + ] + ) + ) + ) + ) + ] + ) + ] + i_215 + ] + i_217 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ] + (force + i_30 + ) + ] + (force + i_120 + ) + ] + ] + ] + ] + ) + ] + (delay + [ + [ + i_94 + (con + string + "4" + ) + ] + [ + [ + [ + (force + (force + i_80 + ) + ) + [ + i_74 + (delay + (lam + i_244 + i_244 + ) + ) + ] + ] + (lam + i_245 + [ + (force + [ + i_38 + i_245 + ] + ) + (lam + i_246 + (lam + i_247 + [ + [ + i_57 + (force + i_114 + ) + ] + i_246 + ] + ) + ) + ] + ) + ] + (force + i_120 + ) + ] + ] + ) + ] + ) + ) + ] + ) + ) + (delay + (force + [ + [ + (force + [ + (force + i_32 + ) + [ + [ + (force + (force + [ + i_56 + (delay + (lam + i_248 + i_248 + ) + ) + ] + ) + ) + (lam + i_249 + [ + [ + (lam + i_250 + i_250 + ) + (force + i_40 + ) + ] + [ + (lam + i_251 + i_251 + ) + [ + (force + [ + i_51 + i_249 + ] + ) + (lam + i_252 + (lam + i_253 + [ + (force + [ + i_42 + i_253 + ] + ) + (lam + i_254 + (lam + i_255 + (lam + i_256 + (force + [ + [ + (force + [ + (force + i_19 + ) + i_256 + ] + ) + (lam + i_257 + [ + (lam + i_258 + (delay + [ + i_258 + i_115 + ] + ) + ) + [ + (lam + i_259 + i_259 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_260 + (lam + i_261 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_261 + ] + ) + (delay + [ + (force + i_4 + ) + (con + string + "-1" + ) + ] + ) + ] + (lam + i_262 + (lam + i_263 + (delay + [ + (force + [ + (force + (force + i_28 + ) + ) + i_262 + ] + ) + (lam + i_264 + (lam + i_265 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_57 + i_264 + ] + i_257 + ] + ] + ) + (delay + i_265 + ) + ] + (delay + [ + i_260 + i_263 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ] + (delay + [ + (force + i_4 + ) + (con + string + "7" + ) + ] + ) + ] + ) + ) + ) + ) + ] + ) + ) + ] + ] + ] + ) + ] + (force + i_119 + ) + ] + ] + ) + (delay + [ + (force + i_4 + ) + (con + string + "6" + ) + ] + ) + ] + (lam + i_266 + (lam + i_267 + (delay + [ + [ + (force + (force + [ + i_56 + (delay + (lam + i_268 + i_268 + ) + ) + ] + ) + ) + (lam + i_269 + [ + [ + (lam + i_270 + i_270 + ) + (force + i_40 + ) + ] + [ + (lam + i_271 + i_271 + ) + [ + (force + [ + i_51 + i_269 + ] + ) + (lam + i_272 + (lam + i_273 + [ + (force + [ + i_42 + i_273 + ] + ) + (lam + i_274 + (lam + i_275 + (lam + i_276 + (force + [ + [ + (force + [ + (force + i_19 + ) + i_276 + ] + ) + (lam + i_277 + [ + (lam + i_278 + (delay + [ + i_278 + i_115 + ] + ) + ) + [ + (lam + i_279 + i_279 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_280 + (lam + i_281 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_281 + ] + ) + (delay + [ + (force + i_4 + ) + (con + string + "-1" + ) + ] + ) + ] + (lam + i_282 + (lam + i_283 + (delay + [ + (force + [ + (force + (force + i_28 + ) + ) + i_282 + ] + ) + (lam + i_284 + (lam + i_285 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_57 + i_284 + ] + i_277 + ] + ] + ) + (delay + i_285 + ) + ] + (delay + [ + i_280 + i_283 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ] + (delay + [ + (force + i_4 + ) + (con + string + "7" + ) + ] + ) + ] + ) + ) + ) + ) + ] + ) + ) + ] + ] + ] + ) + ] + (force + i_119 + ) + ] + ) + ) + ) + ] + ) + ) + ] + ) + (delay + [ + [ + [ + (force + (force + [ + i_90 + (delay + (lam + i_286 + i_286 + ) + ) + ] + ) + ) + (lam + i_287 + (lam + i_288 + (force + [ + [ + (force + [ + i_10 + [ + [ + (force + [ + i_15 + [ + i_59 + [ + i_76 + [ + (force + [ + i_51 + i_287 + ] + ) + (lam + i_289 + (lam + i_290 + i_290 + ) + ) + ] + ] + ] + ] + ) + (lam + i_291 + i_9 + ) + ] + (lam + i_292 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_57 + i_292 + ] + [ + i_118 + i_106 + ] + ] + ] + ) + (delay + i_8 + ) + ] + (delay + [ + (force + i_4 + ) + (con + string + "3" + ) + ] + ) + ] + ) + ) + ] + ] + ) + (delay + [ + [ + (force + i_31 + ) + i_287 + ] + i_288 + ] + ) + ] + (delay + i_288 + ) + ] + ) + ) + ) + ] + (force + i_30 + ) + ] + i_106 + ] + ) + ] + ) + [ + (lam + i_293 + i_293 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_294 + (lam + i_295 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_295 + ] + ) + (delay + [ + (force + i_4 + ) + (con + string + "-1" + ) + ] + ) + ] + (lam + i_296 + (lam + i_297 + (delay + [ + (force + [ + i_51 + i_296 + ] + ) + (lam + i_298 + (lam + i_299 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (lam + i_300 + i_300 + ) + (force + i_11 + ) + ] + i_298 + ] + i_117 + ] + ] + ) + (delay + [ + (force + [ + i_25 + [ + i_76 + i_299 + ] + ] + ) + (lam + i_301 + (lam + i_302 + [ + [ + (force + [ + i_15 + i_301 + ] + ) + (lam + i_303 + [ + (force + i_4 + ) + (con + string + "-1" + ) + ] + ) + ] + (lam + i_304 + i_304 + ) + ] + ) + ) + ] + ) + ] + (delay + [ + i_294 + i_297 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ] + ) + ) + ) + (delay + (force + [ + [ + (force + [ + (force + i_32 + ) + i_113 + ] + ) + (delay + [ + i_5 + (con + unit + () + ) + ] + ) + ] + (lam + i_305 + (lam + i_306 + (delay + (force + [ + [ + (force + [ + (force + i_32 + ) + i_306 + ] + ) + (delay + i_305 + ) + ] + (lam + i_307 + (lam + i_308 + (delay + [ + i_5 + (con + unit + () + ) + ] + ) + ) + ) + ] + ) + ) + ) + ) + ] + ) + ) + ] + ) + ) + ) + ) + ) + ) + ) + ) + ] + ) + ) + ] + ) + ) + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_98 + ) + ] + (con + integer + 1 + ) + ] + ] + (lam + i_309 + i_45 + ) + ] + (lam + i_310 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_98 + ) + ] + (con + integer + 0 + ) + ] + ] + (lam + i_311 + i_46 + ) + ] + (lam + i_312 + [ + (lam + i_313 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + ] + i_3 + ] + ] + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_100 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_314 + [ + [ + i_54 + [ + (lam + i_315 + [ + (lam + i_316 + [ + (lam + i_317 + [ + (lam + i_318 + [ + (lam + i_319 + [ + (lam + i_320 + [ + (lam + i_321 + [ + (lam + i_322 + [ + (lam + i_323 + [ + (lam + i_324 + [ + (lam + i_325 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_316 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_326 + [ + [ + [ + [ + [ + [ + [ + [ + [ + [ + i_52 + [ + [ + (force + i_34 + ) + (lam + i_327 + [ + (lam + i_328 + [ + (lam + i_329 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_328 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_330 + [ + [ + i_50 + [ + i_44 + [ + (force + (builtin + headList + ) + ) + (force + i_329 + ) + ] + ] + ] + [ + i_43 + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_329 + ) + ] + ] + ] + ] + ) + ] + (lam + i_331 + [ + (lam + i_332 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_328 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_327 + ] + ) + ] + ) + ] + [ + (force + (builtin + headList + ) + ) + (force + i_317 + ) + ] + ] + ] + [ + [ + (force + i_34 + ) + i_43 + ] + [ + (force + (builtin + headList + ) + ) + (force + i_318 + ) + ] + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_319 + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_320 + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_321 + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_322 + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_323 + ) + ] + ] + [ + [ + (force + i_34 + ) + (builtin + unBData + ) + ] + [ + (force + (builtin + headList + ) + ) + (force + i_324 + ) + ] + ] + ] + [ + [ + (force + i_34 + ) + [ + [ + (force + (force + i_29 + ) + ) + (builtin + unBData + ) + ] + (lam + i_333 + i_333 + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_325 + ) + ] + ] + ] + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_325 + ) + ] + ] + ] + ) + ] + (lam + i_334 + [ + (lam + i_335 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_324 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_323 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_322 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_321 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_320 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_319 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_318 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_317 + ) + ] + ) + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_316 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_315 + ] + ) + ] + ) + [ + (force + (builtin + headList + ) + ) + (force + i_101 + ) + ] + ] + ] + [ + (lam + i_336 + [ + (lam + i_337 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_337 + ) + ] + ] + (con + integer + 1 + ) + ] + ] + (lam + i_338 + [ + i_48 + [ + i_44 + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_337 + ) + ] + ] + ] + ] + ) + ] + (lam + i_339 + [ + (lam + i_340 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_336 + ] + ) + ] + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_101 + ) + ] + ] + ] + ] + ) + ] + (lam + i_341 + [ + (lam + i_342 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ] + ] + ) + (delay + i_1 + ) + ] + (delay + [ + (lam + i_343 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + (con + string + "PT5" + ) + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + ) + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_100 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_99 + ] + ) + ] + ) + ) + (delay + [ + (force + (force + (builtin + fstPair + ) + ) + ) + [ + (builtin + unConstrData + ) + i_97 + ] + ] + ) + ] + ) + ) + ) + (lam + i_344 + (lam + i_345 + [ + [ + (builtin + addInteger + ) + i_344 + ] + i_345 + ] + ) + ) + ] + ) + (lam + i_346 + (lam + i_347 + (force + [ + [ + (force + [ + i_10 + i_347 + ] + ) + (delay + i_8 + ) + ] + (delay + [ + [ + (force + (builtin + trace + ) + ) + i_346 + ] + i_9 + ] + ) + ] + ) + ) + ) + ] + ) + (delay + (delay + (lam + i_348 + (lam + i_349 + [ + (lam + i_350 + (lam + i_351 + [ + i_350 + i_351 + ] + ) + ) + [ + (lam + i_352 + i_352 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_353 + (lam + i_354 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_354 + ] + ) + (delay + (force + i_18 + ) + ) + ] + (lam + i_355 + (lam + i_356 + (delay + [ + (force + [ + (force + (force + i_28 + ) + ) + i_355 + ] + ) + (lam + i_357 + (lam + i_358 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_348 + i_357 + ] + i_349 + ] + ] + ) + (delay + [ + (force + i_17 + ) + i_358 + ] + ) + ] + (delay + [ + i_353 + i_356 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ) + ) + ) + ] + ) + (delay + (delay + (lam + i_359 + (lam + i_360 + (lam + i_361 + (lam + i_362 + [ + (lam + i_363 + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_364 + i_364 + ) + ) + ] + ) + ) + (lam + i_365 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_365 + ] + ) + (lam + i_366 + (lam + i_367 + [ + [ + (force + (force + i_27 + ) + ) + i_366 + ] + [ + [ + [ + (force + [ + (force + (force + i_89 + ) + ) + i_367 + ] + ) + (lam + i_368 + i_368 + ) + ] + (lam + i_369 + (lam + i_370 + i_370 + ) + ) + ] + (lam + i_371 + i_371 + ) + ] + ] + ) + ) + ] + ) + ] + [ + [ + [ + (force + (force + (force + i_91 + ) + ) + ) + i_359 + ] + i_362 + ] + i_363 + ] + ] + ) + [ + (lam + i_372 + [ + [ + (force + i_372 + ) + (force + i_31 + ) + ] + (force + i_30 + ) + ] + ) + (delay + (lam + i_373 + (lam + i_374 + [ + [ + i_373 + [ + [ + (force + (force + i_27 + ) + ) + i_360 + ] + i_361 + ] + ] + i_374 + ] + ) + ) + ) + ] + ] + ) + ) + ) + ) + ) + ) + ] + ) + (delay + (delay + (delay + (lam + i_375 + (lam + i_376 + (lam + i_377 + [ + [ + [ + (force + (force + [ + i_90 + (delay + (lam + i_378 + i_378 + ) + ) + ] + ) + ) + (force + i_31 + ) + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_379 + i_379 + ) + ) + ] + ) + ) + (lam + i_380 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_380 + ] + ) + (lam + i_381 + (lam + i_382 + [ + [ + (force + (force + i_27 + ) + ) + i_381 + ] + [ + (force + (force + i_86 + ) + ) + i_382 + ] + ] + ) + ) + ] + ) + ] + [ + [ + [ + (force + (force + [ + i_90 + (delay + (lam + i_383 + i_383 + ) + ) + ] + ) + ) + (lam + i_384 + (lam + i_385 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_384 + ] + ) + (lam + i_386 + (lam + i_387 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (force + [ + i_74 + (delay + (lam + i_388 + i_388 + ) + ) + ] + ) + ) + [ + (force + i_85 + ) + [ + [ + (force + i_83 + ) + (lam + i_389 + (lam + i_390 + (force + [ + [ + (force + [ + i_10 + i_389 + ] + ) + (delay + i_8 + ) + ] + (delay + i_390 + ) + ] + ) + ) + ) + ] + i_9 + ] + ] + ] + (lam + i_391 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_391 + ] + ) + (lam + i_392 + (lam + i_393 + [ + [ + i_375 + i_392 + ] + i_386 + ] + ) + ) + ] + ) + ] + i_376 + ] + ] + ) + (delay + i_385 + ) + ] + (delay + [ + [ + (force + i_31 + ) + i_384 + ] + i_385 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ] + (force + i_30 + ) + ] + i_377 + ] + ] + ] + [ + [ + (force + (force + [ + i_82 + (delay + (lam + i_394 + i_394 + ) + ) + ] + ) + ) + (lam + i_395 + [ + (force + [ + (force + (force + i_28 + ) + ) + i_395 + ] + ) + (lam + i_396 + (lam + i_397 + [ + (lam + i_398 + [ + [ + (force + (force + i_27 + ) + ) + i_396 + ] + [ + i_398 + i_377 + ] + ] + ) + [ + (lam + i_399 + i_399 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_400 + (lam + i_401 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_401 + ] + ) + (delay + [ + (force + (force + i_88 + ) + ) + i_397 + ] + ) + ] + (lam + i_402 + (lam + i_403 + (delay + [ + (force + [ + (force + (force + i_28 + ) + ) + i_402 + ] + ) + (lam + i_404 + (lam + i_405 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_375 + i_404 + ] + i_396 + ] + ] + ) + (delay + [ + [ + (force + (force + i_87 + ) + ) + i_397 + ] + i_405 + ] + ) + ] + (delay + [ + i_400 + i_403 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ] + ] + ) + ) + ] + ) + ] + i_376 + ] + ] + ) + ) + ) + ) + ) + ) + ] + ) + [ + (lam + i_406 + i_406 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_407 + (lam + i_408 + (delay + (delay + (lam + i_409 + (lam + i_410 + (lam + i_411 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_411 + ] + ) + (delay + i_410 + ) + ] + (lam + i_412 + (lam + i_413 + (delay + [ + [ + i_409 + i_412 + ] + [ + [ + [ + (force + (force + [ + i_407 + (delay + (lam + i_414 + i_414 + ) + ) + ] + ) + ) + i_409 + ] + i_410 + ] + i_413 + ] + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + ) + ) + ) + (delay + (delay + (lam + i_415 + (delay + (lam + i_416 + (lam + i_417 + (lam + i_418 + [ + i_416 + i_415 + ] + ) + ) + ) + ) + ) + ) + ) + ] + (delay + (delay + (lam + i_419 + (lam + i_420 + (delay + (lam + i_421 + (lam + i_422 + (lam + i_423 + [ + [ + i_422 + i_419 + ] + i_420 + ] + ) + ) + ) + ) + ) + ) + ) + ) + ] + (delay + (delay + (lam + i_424 + (delay + (lam + i_425 + (lam + i_426 + (lam + i_427 + [ + i_427 + i_424 + ] + ) + ) + ) + ) + ) + ) + ) + ] + (delay + (delay + (lam + i_428 + i_428 + ) + ) + ) + ] + ) + (delay + (lam + i_429 + [ + [ + (force + i_68 + ) + (lam + i_430 + (lam + i_431 + [ + [ + [ + (force + [ + (force + i_84 + ) + i_429 + ] + ) + (lam + i_432 + (lam + i_433 + i_432 + ) + ) + ] + i_430 + ] + i_431 + ] + ) + ) + ] + [ + (force + [ + (force + i_84 + ) + i_429 + ] + ) + (lam + i_434 + (lam + i_435 + i_435 + ) + ) + ] + ] + ) + ) + ] + ) + ) + (delay + (lam + i_436 + (lam + i_437 + (delay + (lam + i_438 + [ + [ + i_438 + i_436 + ] + i_437 + ] + ) + ) + ) + ) + ) + ] + (delay + (lam + i_439 + i_439 + ) + ) + ] + ) + [ + (lam + i_440 + i_440 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_441 + (lam + i_442 + (delay + (delay + (lam + i_443 + (lam + i_444 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_444 + ] + ) + (delay + (force + i_30 + ) + ) + ] + (lam + i_445 + (lam + i_446 + (delay + [ + [ + (force + i_31 + ) + [ + i_443 + i_445 + ] + ] + [ + [ + (force + (force + [ + i_441 + (delay + (lam + i_447 + i_447 + ) + ) + ] + ) + ) + i_443 + ] + i_446 + ] + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + (delay + (delay + (delay + (lam + i_448 + (lam + i_449 + (lam + i_450 + (lam + i_451 + [ + [ + [ + [ + (force + (force + i_448 + ) + ) + (force + i_70 + ) + ] + i_449 + ] + i_451 + ] + i_450 + ] + ) + ) + ) + ) + ) + ) + ) + ] + ) + (delay + (delay + (lam + i_452 + (lam + i_453 + [ + [ + (force + (force + i_452 + ) + ) + [ + (lam + i_454 + [ + [ + (force + i_68 + ) + (lam + i_455 + (lam + i_456 + [ + [ + [ + (force + [ + (force + i_79 + ) + i_454 + ] + ) + (lam + i_457 + (lam + i_458 + i_457 + ) + ) + ] + i_455 + ] + i_456 + ] + ) + ) + ] + [ + (force + [ + (force + i_79 + ) + i_454 + ] + ) + (lam + i_459 + (lam + i_460 + i_460 + ) + ) + ] + ] + ) + [ + [ + (force + i_78 + ) + i_62 + ] + i_8 + ] + ] + ] + i_453 + ] + ) + ) + ) + ) + ] + ) + ) + (delay + (lam + i_461 + (lam + i_462 + (delay + (lam + i_463 + [ + [ + i_463 + i_461 + ] + i_462 + ] + ) + ) + ) + ) + ) + ] + (delay + (lam + i_464 + i_464 + ) + ) + ] + ) + (delay + (delay + (lam + i_465 + (lam + i_466 + [ + i_465 + i_466 + ] + ) + ) + ) + ) + ] + ) + (lam + i_467 + [ + (force + [ + i_42 + i_467 + ] + ) + (lam + i_468 + (lam + i_469 + (lam + i_470 + i_468 + ) + ) + ) + ] + ) + ] + ) + [ + (lam + i_471 + i_471 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_472 + (lam + i_473 + [ + (lam + i_474 + [ + (lam + i_475 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_39 + (force + i_474 + ) + ] + (con + integer + 1 + ) + ] + ] + ) + (delay + [ + [ + i_67 + [ + i_472 + [ + [ + (force + [ + i_71 + (delay + (lam + i_476 + i_476 + ) + ) + ] + ) + (force + i_475 + ) + ] + i_473 + ] + ] + ] + [ + i_472 + [ + [ + (force + [ + i_66 + (delay + (lam + i_477 + i_477 + ) + ) + ] + ) + (force + i_475 + ) + ] + i_473 + ] + ] + ] + ) + ] + (delay + i_473 + ) + ] + ) + ) + (delay + [ + [ + (lam + i_478 + (lam + i_479 + [ + [ + (builtin + divideInteger + ) + i_478 + ] + i_479 + ] + ) + ) + (force + i_474 + ) + ] + (con + integer + 2 + ) + ] + ) + ] + ) + (delay + [ + [ + [ + [ + (force + (force + [ + i_74 + (delay + (lam + i_480 + i_480 + ) + ) + ] + ) + ) + [ + (lam + i_481 + [ + [ + (force + i_68 + ) + (lam + i_482 + (lam + i_483 + [ + [ + [ + (force + i_72 + ) + i_481 + ] + i_483 + ] + i_482 + ] + ) + ) + ] + [ + (force + i_73 + ) + i_481 + ] + ] + ) + (force + i_70 + ) + ] + ] + (lam + i_484 + (lam + i_485 + [ + [ + (builtin + addInteger + ) + i_485 + ] + (con + integer + 1 + ) + ] + ) + ) + ] + i_473 + ] + (con + integer + 0 + ) + ] + ) + ] + ) + ) + ] + ] + ] + ) + [ + (lam + i_486 + i_486 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_487 + (lam + i_488 + (delay + (delay + (lam + i_489 + (lam + i_490 + (lam + i_491 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_491 + ] + ) + (delay + [ + (force + i_73 + ) + i_489 + ] + ) + ] + (lam + i_492 + (lam + i_493 + (delay + [ + [ + [ + (force + i_72 + ) + i_489 + ] + [ + i_490 + i_492 + ] + ] + [ + [ + [ + (force + (force + [ + i_487 + (delay + (lam + i_494 + i_494 + ) + ) + ] + ) + ) + i_489 + ] + i_490 + ] + i_493 + ] + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + (delay + (lam + i_495 + [ + (force + [ + (force + i_69 + ) + i_495 + ] + ) + (lam + i_496 + (lam + i_497 + i_497 + ) + ) + ] + ) + ) + ] + ) + (delay + (lam + i_498 + [ + (force + [ + (force + i_69 + ) + i_498 + ] + ) + (lam + i_499 + (lam + i_500 + i_499 + ) + ) + ] + ) + ) + ] + ) + [ + (lam + i_501 + i_501 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_502 + (lam + i_503 + (delay + (lam + i_504 + (lam + i_505 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanEqualsInteger + ) + i_504 + ] + (con + integer + 0 + ) + ] + ] + i_8 + ] + i_9 + ] + ] + ) + (delay + (force + i_30 + ) + ) + ] + (delay + (force + [ + [ + (force + [ + (force + i_32 + ) + i_505 + ] + ) + (delay + (force + i_30 + ) + ) + ] + (lam + i_506 + (lam + i_507 + (delay + [ + [ + (force + i_31 + ) + i_506 + ] + [ + [ + (force + [ + i_502 + (delay + (lam + i_508 + i_508 + ) + ) + ] + ) + [ + [ + (builtin + subtractInteger + ) + i_504 + ] + (con + integer + 1 + ) + ] + ] + i_507 + ] + ] + ) + ) + ) + ] + ) + ) + ] + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + (delay + [ + [ + (force + i_68 + ) + (lam + i_509 + (lam + i_510 + (lam + i_511 + [ + i_509 + [ + i_510 + i_511 + ] + ] + ) + ) + ) + ] + (lam + i_512 + i_512 + ) + ] + ) + ] + ) + ) + (delay + (lam + i_513 + (lam + i_514 + (delay + (lam + i_515 + [ + [ + i_515 + i_513 + ] + i_514 + ] + ) + ) + ) + ) + ) + ] + (delay + (lam + i_516 + i_516 + ) + ) + ] + ) + [ + (lam + i_517 + i_517 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_518 + (lam + i_519 + (lam + i_520 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_519 + ] + ) + (delay + i_520 + ) + ] + (lam + i_521 + (lam + i_522 + (delay + [ + (force + [ + i_51 + i_521 + ] + ) + (lam + i_523 + (lam + i_524 + [ + (force + [ + i_7 + i_523 + ] + ) + (lam + i_525 + (lam + i_526 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_520 + ] + ) + (delay + (force + [ + [ + (force + [ + (force + i_32 + ) + i_520 + ] + ) + (delay + i_519 + ) + ] + (lam + i_527 + (lam + i_528 + (delay + (error + + ) + ) + ) + ) + ] + ) + ) + ] + (lam + i_529 + (lam + i_530 + (delay + [ + (force + [ + i_51 + i_529 + ] + ) + (lam + i_531 + (lam + i_532 + [ + (force + [ + i_7 + i_531 + ] + ) + (lam + i_533 + (lam + i_534 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanByteString + ) + i_525 + ] + i_533 + ] + ] + i_8 + ] + i_9 + ] + ] + ) + (delay + [ + [ + (force + i_31 + ) + i_521 + ] + [ + [ + i_518 + i_522 + ] + i_520 + ] + ] + ) + ] + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanEqualsByteString + ) + i_525 + ] + i_533 + ] + ] + i_9 + ] + i_8 + ] + ] + ) + (delay + [ + [ + (force + i_31 + ) + i_529 + ] + [ + [ + i_518 + i_519 + ] + i_530 + ] + ] + ) + ] + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + i_64 + i_526 + ] + i_534 + ] + ] + ) + (delay + [ + [ + (force + i_31 + ) + i_521 + ] + [ + [ + i_518 + i_522 + ] + i_520 + ] + ] + ) + ] + (delay + [ + [ + (force + i_31 + ) + i_529 + ] + [ + [ + i_518 + i_519 + ] + i_530 + ] + ] + ) + ] + ) + ) + ] + ) + ) + ] + ) + ) + ) + ] + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ) + ] + ] + ] + ) + [ + (lam + i_535 + i_535 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_536 + (lam + i_537 + (delay + (lam + i_538 + (lam + i_539 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_539 + ] + ) + (delay + (force + i_30 + ) + ) + ] + (lam + i_540 + (lam + i_541 + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + i_64 + i_538 + ] + (con + integer + 0 + ) + ] + ] + ) + (delay + i_539 + ) + ] + (delay + [ + [ + (force + [ + i_536 + (delay + (lam + i_542 + i_542 + ) + ) + ] + ) + [ + [ + i_65 + i_538 + ] + (con + integer + 1 + ) + ] + ] + i_541 + ] + ) + ] + ) + ) + ) + ) + ] + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + (lam + i_543 + (lam + i_544 + [ + [ + (builtin + subtractInteger + ) + i_543 + ] + i_544 + ] + ) + ) + ] + ) + (lam + i_545 + (lam + i_546 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanEqualsInteger + ) + i_545 + ] + i_546 + ] + ] + i_8 + ] + i_9 + ] + ) + ) + ] + ) + (delay + (lam + i_547 + (lam + i_548 + [ + [ + i_62 + [ + [ + i_58 + [ + i_59 + i_547 + ] + ] + [ + i_59 + i_548 + ] + ] + ] + [ + [ + (lam + i_549 + (lam + i_550 + (force + [ + [ + (force + [ + (force + i_19 + ) + i_549 + ] + ) + (lam + i_551 + (delay + (force + [ + [ + (force + [ + (force + i_19 + ) + i_550 + ] + ) + (lam + i_552 + (delay + [ + [ + (force + [ + i_23 + i_551 + ] + ) + (lam + i_553 + [ + [ + (force + [ + i_23 + i_552 + ] + ) + (lam + i_554 + [ + [ + i_58 + i_553 + ] + i_554 + ] + ) + ] + (lam + i_555 + (lam + i_556 + (lam + i_557 + i_9 + ) + ) + ) + ] + ) + ] + (lam + i_558 + (lam + i_559 + (lam + i_560 + [ + [ + (force + [ + i_23 + i_552 + ] + ) + (lam + i_561 + i_9 + ) + ] + (lam + i_562 + (lam + i_563 + (lam + i_564 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + i_558 + ] + i_562 + ] + ] + i_8 + ] + i_9 + ] + ] + ) + (delay + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + i_559 + ] + i_563 + ] + ] + i_8 + ] + i_9 + ] + ] + ) + (delay + [ + [ + i_61 + i_560 + ] + i_564 + ] + ) + ] + (delay + i_9 + ) + ] + ) + ) + ] + (delay + i_9 + ) + ] + ) + ) + ) + ) + ] + ) + ) + ) + ] + ) + ) + ] + (delay + i_9 + ) + ] + ) + ) + ) + ] + (delay + (force + [ + [ + (force + [ + (force + i_19 + ) + i_550 + ] + ) + (lam + i_565 + (delay + i_9 + ) + ) + ] + (delay + i_8 + ) + ] + ) + ) + ] + ) + ) + ) + [ + i_60 + i_547 + ] + ] + [ + i_60 + i_548 + ] + ] + ] + ) + ) + ) + ] + ) + (lam + i_566 + (lam + i_567 + (force + [ + [ + (force + [ + i_10 + i_566 + ] + ) + (delay + i_567 + ) + ] + (delay + i_9 + ) + ] + ) + ) + ) + ] + ) + (lam + i_568 + (lam + i_569 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + i_568 + ] + i_569 + ] + ] + i_8 + ] + i_9 + ] + ) + ) + ] + ) + (lam + i_570 + [ + (force + [ + i_25 + i_570 + ] + ) + (lam + i_571 + (lam + i_572 + i_572 + ) + ) + ] + ) + ] + ) + (lam + i_573 + [ + (force + [ + i_25 + i_573 + ] + ) + (lam + i_574 + (lam + i_575 + i_574 + ) + ) + ] + ) + ] + ) + (lam + i_576 + (lam + i_577 + [ + [ + (force + [ + i_15 + i_576 + ] + ) + (lam + i_578 + [ + [ + (force + [ + i_15 + i_577 + ] + ) + (lam + i_579 + [ + [ + i_57 + i_578 + ] + i_579 + ] + ) + ] + (lam + i_580 + i_9 + ) + ] + ) + ] + (lam + i_581 + [ + [ + (force + [ + i_15 + i_577 + ] + ) + (lam + i_582 + i_9 + ) + ] + (lam + i_583 + [ + [ + i_57 + i_581 + ] + i_583 + ] + ) + ] + ) + ] + ) + ) + ] + ) + (lam + i_584 + (lam + i_585 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsByteString + ) + i_584 + ] + i_585 + ] + ] + i_8 + ] + i_9 + ] + ) + ) + ] + ) + [ + (lam + i_586 + i_586 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_587 + (lam + i_588 + (delay + (delay + (lam + i_589 + (lam + i_590 + (force + [ + [ + (force + [ + (force + i_32 + ) + i_590 + ] + ) + (delay + (force + i_30 + ) + ) + ] + (lam + i_591 + (lam + i_592 + (delay + [ + [ + (force + i_31 + ) + [ + i_589 + i_591 + ] + ] + [ + [ + (force + (force + [ + i_587 + (delay + (lam + i_593 + i_593 + ) + ) + ] + ) + ) + i_589 + ] + i_592 + ] + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + ) + ) + ] + ] + ] + ) + ) + (lam + i_594 + (lam + i_595 + (delay + (lam + i_596 + [ + [ + i_596 + i_594 + ] + i_595 + ] + ) + ) + ) + ) + ] + (lam + i_597 + i_597 + ) + ] + ) + ) + (lam + i_598 + (lam + i_599 + (lam + i_600 + (lam + i_601 + (lam + i_602 + (lam + i_603 + (lam + i_604 + (lam + i_605 + (lam + i_606 + (lam + i_607 + (delay + (lam + i_608 + [ + [ + [ + [ + [ + [ + [ + [ + [ + [ + i_608 + i_598 + ] + i_599 + ] + i_600 + ] + i_601 + ] + i_602 + ] + i_603 + ] + i_604 + ] + i_605 + ] + i_606 + ] + i_607 + ] + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ] + (lam + i_609 + i_609 + ) + ] + ) + ) + (lam + i_610 + (lam + i_611 + (delay + (lam + i_612 + [ + [ + i_612 + i_610 + ] + i_611 + ] + ) + ) + ) + ) + ] + (lam + i_613 + i_613 + ) + ] + ) + ) + (lam + i_614 + (delay + (lam + i_615 + [ + i_615 + i_614 + ] + ) + ) + ) + ] + (lam + i_616 + i_616 + ) + ] + ) + ) + ) + (delay + (lam + i_617 + (lam + i_618 + i_617 + ) + ) + ) + ] + (delay + (lam + i_619 + (lam + i_620 + i_620 + ) + ) + ) + ] + (lam + i_621 + i_621 + ) + ] + ) + (lam + i_622 + [ + (lam + i_623 + [ + (lam + i_624 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_623 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_625 + [ + [ + i_6 + [ + (lam + i_626 + [ + (lam + i_627 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_627 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_628 + [ + (builtin + unBData + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_627 + ) + ] + ] + ] + ) + ] + (lam + i_629 + [ + (lam + i_630 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_626 + ] + ) + ] + ) + [ + (force + (builtin + headList + ) + ) + (force + i_624 + ) + ] + ] + ] + [ + (builtin + unIData + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_624 + ) + ] + ] + ] + ] + ) + ] + (lam + i_631 + [ + (lam + i_632 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_623 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_622 + ] + ) + ] + ) + ] + ) + (lam + i_633 + [ + (lam + i_634 + [ + (lam + i_635 + [ + (lam + i_636 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_634 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_637 + [ + [ + [ + i_41 + [ + i_26 + [ + (force + (builtin + headList + ) + ) + (force + i_635 + ) + ] + ] + ] + [ + [ + [ + (force + (force + i_33 + ) + ) + (builtin + unBData + ) + ] + [ + [ + (force + (force + i_33 + ) + ) + (builtin + unBData + ) + ] + (builtin + unIData + ) + ] + ] + [ + (force + (builtin + headList + ) + ) + (force + i_636 + ) + ] + ] + ] + [ + [ + (force + i_20 + ) + (builtin + unBData + ) + ] + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_636 + ) + ] + ] + ] + ] + ) + ] + (lam + i_638 + [ + (lam + i_639 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_635 + ) + ] + ) + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_634 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_633 + ] + ) + ] + ) + ] + ) + ) + (lam + i_640 + (lam + i_641 + (lam + i_642 + (delay + (lam + i_643 + [ + [ + [ + i_643 + i_640 + ] + i_641 + ] + i_642 + ] + ) + ) + ) + ) + ) + ] + (lam + i_644 + i_644 + ) + ] + ) + (delay + (lam + i_645 + [ + (lam + i_646 + [ + (lam + i_647 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_646 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_648 + [ + [ + (lam + i_649 + (lam + i_650 + [ + [ + i_37 + i_649 + ] + i_650 + ] + ) + ) + [ + (builtin + unBData + ) + [ + (force + (builtin + headList + ) + ) + (force + i_647 + ) + ] + ] + ] + [ + [ + (force + i_34 + ) + (lam + i_651 + [ + (lam + i_652 + [ + (lam + i_653 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_652 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_654 + [ + [ + (lam + i_655 + (lam + i_656 + [ + [ + i_35 + i_655 + ] + i_656 + ] + ) + ) + [ + i_26 + [ + (force + (builtin + headList + ) + ) + (force + i_653 + ) + ] + ] + ] + [ + [ + [ + (force + (force + i_33 + ) + ) + (builtin + unBData + ) + ] + [ + [ + (force + (force + i_29 + ) + ) + (lam + i_657 + [ + (lam + i_658 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_39 + (force + i_658 + ) + ] + (con + integer + -1 + ) + ] + ] + ) + (delay + (force + i_658 + ) + ) + ] + (delay + [ + (force + i_4 + ) + (con + string + "-3" + ) + ] + ) + ] + ) + ) + (delay + [ + (builtin + unIData + ) + i_657 + ] + ) + ] + ) + ] + [ + [ + (force + (force + i_33 + ) + ) + (builtin + unBData + ) + ] + (lam + i_659 + [ + (lam + i_660 + (force + [ + [ + (force + [ + i_10 + [ + [ + i_39 + (force + i_660 + ) + ] + (con + integer + 0 + ) + ] + ] + ) + (delay + (force + i_660 + ) + ) + ] + (delay + [ + (force + i_4 + ) + (con + string + "-2" + ) + ] + ) + ] + ) + ) + (delay + [ + (builtin + unIData + ) + i_659 + ] + ) + ] + ) + ] + ] + ] + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_653 + ) + ] + ] + ] + ] + ) + ] + (lam + i_661 + [ + (lam + i_662 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_652 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_651 + ] + ) + ] + ) + ] + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_647 + ) + ] + ] + ] + ] + ) + ] + (lam + i_663 + [ + (lam + i_664 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_646 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_645 + ] + ) + ] + ) + ) + ] + ) + (lam + i_665 + (lam + i_666 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + lessThanEqualsInteger + ) + i_665 + ] + i_666 + ] + ] + i_9 + ] + i_8 + ] + ) + ) + ] + ) + ) + (lam + i_667 + (lam + i_668 + (delay + (lam + i_669 + [ + [ + i_669 + i_667 + ] + i_668 + ] + ) + ) + ) + ) + ] + (lam + i_670 + i_670 + ) + ] + ) + ) + (lam + i_671 + (lam + i_672 + (delay + (lam + i_673 + [ + [ + i_673 + i_671 + ] + i_672 + ] + ) + ) + ) + ) + ] + (lam + i_674 + i_674 + ) + ] + ) + (delay + (lam + i_675 + [ + (lam + i_676 + (lam + i_677 + [ + i_676 + [ + (builtin + unListData + ) + i_677 + ] + ] + ) + ) + [ + (lam + i_678 + i_678 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_679 + (lam + i_680 + [ + [ + [ + [ + (force + (force + (builtin + chooseList + ) + ) + ) + i_680 + ] + (lam + i_681 + (force + i_30 + ) + ) + ] + (lam + i_682 + [ + [ + (force + i_31 + ) + [ + i_675 + [ + (force + (builtin + headList + ) + ) + i_680 + ] + ] + ] + [ + i_679 + [ + (force + (builtin + tailList + ) + ) + i_680 + ] + ] + ] + ) + ] + i_1 + ] + ) + ) + ] + ] + ] + ) + ) + ] + ) + (delay + (delay + (lam + i_683 + (lam + i_684 + [ + (lam + i_685 + (lam + i_686 + [ + i_685 + [ + (builtin + unMapData + ) + i_686 + ] + ] + ) + ) + [ + (lam + i_687 + i_687 + ) + [ + (force + (force + i_0 + ) + ) + (lam + i_688 + (lam + i_689 + [ + (lam + i_690 + [ + [ + [ + [ + (force + (force + (builtin + chooseList + ) + ) + ) + i_689 + ] + (lam + i_691 + (force + i_30 + ) + ) + ] + (lam + i_692 + [ + [ + (force + i_31 + ) + [ + [ + (force + (force + i_27 + ) + ) + [ + i_683 + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_690 + ) + ] + ] + ] + [ + i_684 + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_690 + ) + ] + ] + ] + ] + [ + i_688 + [ + (force + (builtin + tailList + ) + ) + i_689 + ] + ] + ] + ) + ] + i_1 + ] + ) + (delay + [ + (force + (builtin + headList + ) + ) + i_689 + ] + ) + ] + ) + ) + ] + ] + ] + ) + ) + ) + ) + ] + ) + ) + ) + (delay + (delay + (lam + i_693 + (lam + i_694 + i_693 + ) + ) + ) + ) + ] + (delay + (lam + i_695 + (lam + i_696 + (delay + (lam + i_697 + (lam + i_698 + [ + [ + i_698 + i_695 + ] + i_696 + ] + ) + ) + ) + ) + ) + ) + ] + (delay + (lam + i_699 + i_699 + ) + ) + ] + ) + (delay + (delay + (lam + i_700 + (lam + i_701 + (lam + i_702 + [ + (lam + i_703 + [ + (lam + i_704 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_703 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_705 + [ + [ + (force + (force + i_27 + ) + ) + [ + i_700 + [ + (force + (builtin + headList + ) + ) + (force + i_704 + ) + ] + ] + ] + [ + i_701 + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_704 + ) + ] + ] + ] + ] + ) + ] + (lam + i_706 + [ + (lam + i_707 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_703 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_702 + ] + ) + ] + ) + ) + ) + ) + ) + ] + ) + ) + (delay + (delay + (lam + i_708 + (lam + i_709 + (delay + (lam + i_710 + [ + [ + i_710 + i_708 + ] + i_709 + ] + ) + ) + ) + ) + ) + ) + ] + (delay + (delay + (lam + i_711 + i_711 + ) + ) + ) + ] + ) + (lam + i_712 + [ + (lam + i_713 + [ + (lam + i_714 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_713 + ) + ] + ] + (con + integer + 0 + ) + ] + ] + (lam + i_715 + [ + [ + i_24 + [ + i_16 + [ + (force + (builtin + headList + ) + ) + (force + i_714 + ) + ] + ] + ] + [ + [ + (force + i_20 + ) + (lam + i_716 + [ + (lam + i_717 + [ + (lam + i_718 + [ + (lam + i_719 + [ + (lam + i_720 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_720 + ) + ] + (con + integer + 1 + ) + ] + ] + (lam + i_721 + [ + [ + [ + i_22 + [ + (builtin + unIData + ) + [ + (force + (builtin + headList + ) + ) + (force + i_718 + ) + ] + ] + ] + [ + (builtin + unIData + ) + [ + (force + (builtin + headList + ) + ) + (force + i_719 + ) + ] + ] + ] + [ + (builtin + unIData + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_719 + ) + ] + ] + ] + ] + ) + ] + (lam + i_722 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_720 + ) + ] + (con + integer + 0 + ) + ] + ] + (lam + i_723 + [ + i_21 + [ + i_16 + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_717 + ) + ] + ] + ] + ] + ) + ] + (lam + i_724 + [ + (lam + i_725 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_717 + ) + ] + ) + ] + ) + (delay + [ + (force + (builtin + tailList + ) + ) + (force + i_718 + ) + ] + ) + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_717 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_716 + ] + ) + ] + ) + ] + [ + (force + (builtin + headList + ) + ) + [ + (force + (builtin + tailList + ) + ) + (force + i_714 + ) + ] + ] + ] + ] + ) + ] + (lam + i_726 + [ + (lam + i_727 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_713 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_712 + ] + ) + ] + ) + ] + ) + ) + (lam + i_728 + (lam + i_729 + (delay + (lam + i_730 + [ + [ + i_730 + i_728 + ] + i_729 + ] + ) + ) + ) + ) + ] + (lam + i_731 + i_731 + ) + ] + ) + ) + ) + (lam + i_732 + (delay + (lam + i_733 + (lam + i_734 + [ + i_733 + i_732 + ] + ) + ) + ) + ) + ] + (lam + i_735 + (lam + i_736 + (lam + i_737 + (delay + (lam + i_738 + (lam + i_739 + [ + [ + [ + i_739 + i_735 + ] + i_736 + ] + i_737 + ] + ) + ) + ) + ) + ) + ) + ] + (lam + i_740 + i_740 + ) + ] + ) + (delay + (lam + i_741 + (lam + i_742 + [ + (lam + i_743 + [ + (lam + i_744 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_744 + ) + ] + (con + integer + 0 + ) + ] + ] + (lam + i_745 + [ + (force + i_17 + ) + [ + i_741 + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_743 + ) + ] + ] + ] + ] + ) + ] + (lam + i_746 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_744 + ) + ] + (con + integer + 1 + ) + ] + ] + (lam + i_747 + (force + i_18 + ) + ) + ] + (lam + i_748 + [ + (lam + i_749 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_743 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_742 + ] + ) + ] + ) + ) + ) + ] + ) + ) + ) + (delay + (lam + i_750 + (delay + (lam + i_751 + (lam + i_752 + [ + i_751 + i_750 + ] + ) + ) + ) + ) + ) + ] + (delay + (delay + (lam + i_753 + (lam + i_754 + i_754 + ) + ) + ) + ) + ] + (delay + (lam + i_755 + i_755 + ) + ) + ] + ) + (lam + i_756 + [ + (lam + i_757 + [ + (lam + i_758 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_758 + ) + ] + (con + integer + 1 + ) + ] + ] + (lam + i_759 + [ + i_14 + [ + (builtin + unBData + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_757 + ) + ] + ] + ] + ] + ) + ] + (lam + i_760 + [ + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + (force + i_758 + ) + ] + (con + integer + 0 + ) + ] + ] + (lam + i_761 + [ + i_13 + [ + (builtin + unBData + ) + [ + (force + (builtin + headList + ) + ) + [ + (force + (force + (builtin + sndPair + ) + ) + ) + (force + i_757 + ) + ] + ] + ] + ] + ) + ] + (lam + i_762 + [ + (lam + i_763 + (error + + ) + ) + [ + (force + [ + i_2 + [ + [ + (force + (builtin + trace + ) + ) + i_12 + ] + i_1 + ] + ] + ) + i_3 + ] + ] + ) + ] + i_3 + ] + ) + ] + i_3 + ] + ) + (delay + [ + (force + (force + (builtin + fstPair + ) + ) + ) + (force + i_757 + ) + ] + ) + ] + ) + (delay + [ + (builtin + unConstrData + ) + i_756 + ] + ) + ] + ) + ] + ) + ) + ) + (lam + i_764 + (delay + (lam + i_765 + (lam + i_766 + [ + i_765 + i_764 + ] + ) + ) + ) + ) + ] + (lam + i_767 + (delay + (lam + i_768 + (lam + i_769 + [ + i_769 i_767 + ] + ) + ) + ) + ) + ] + (lam i_770 i_770) + ] + ) + (con string "PT1") + ] + ) + (delay + (lam + i_771 + (lam + i_772 + (force + [ + [ + (force + [ + i_10 + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsByteString + ) + [ + (force + [ + i_7 + i_771 + ] + ) + (lam + i_773 + (lam + i_774 + i_773 + ) + ) + ] + ] + [ + (force + [ + i_7 + i_772 + ] + ) + (lam + i_775 + (lam + i_776 + i_775 + ) + ) + ] + ] + ] + i_8 + ] + i_9 + ] + ] + ) + (delay + [ + [ + [ + (force + (builtin + ifThenElse + ) + ) + [ + [ + (builtin + equalsInteger + ) + [ + (force + [ + i_7 + i_771 + ] + ) + (lam + i_777 + (lam + i_778 + i_778 + ) + ) + ] + ] + [ + (force + [ + i_7 + i_772 + ] + ) + (lam + i_779 + (lam + i_780 + i_780 + ) + ) + ] + ] + ] + i_8 + ] + i_9 + ] + ) + ] + (delay i_9) + ] + ) + ) + ) + ) + ] + ) + ) + ) + (delay (lam i_781 (lam i_782 i_781))) + ] + (delay (lam i_783 (lam i_784 i_784))) + ] + (lam i_785 i_785) + ] + ) + ) + (lam + i_786 + (lam + i_787 + (delay (lam i_788 [ [ i_788 i_786 ] i_787 ])) + ) + ) + ] + (lam i_789 i_789) + ] + ) + (lam i_790 [ (force i_4) (con string "1") ]) + ] + ) + (delay + (lam + i_791 + [ + (lam i_792 (error )) + [ + (force + [ i_2 [ [ (force (builtin trace)) i_791 ] i_1 ] ] + ) + i_3 + ] + ] + ) + ) + ] + ) + (con unit ()) + ] + ) + ) + (delay (lam i_793 i_793)) + ] + (lam i_794 i_794) + ] + ) + (delay + (delay + (lam + i_795 + [ + (lam i_796 [ i_796 i_796 ]) + (lam i_797 (lam i_798 [ [ i_795 [ i_797 i_797 ] ] i_798 ])) + ] + ) + ) + ) + ] +) \ No newline at end of file