diff --git a/2020/src/day18.rs b/2020/src/day18.rs index 5b3d619..5d264a7 100644 --- a/2020/src/day18.rs +++ b/2020/src/day18.rs @@ -35,7 +35,7 @@ use aoc_runner_derive::{aoc, aoc_generator}; #[derive(Clone, Copy, Debug, PartialEq)] enum Token { - Num(u32), + Num(u64), Add, Mul, Open, @@ -43,232 +43,6 @@ enum Token { Space, } -#[derive(Debug, PartialEq)] -enum Ast { - Add(Box, Box), - Mul(Box, Box), - Num(u32), -} - -fn eval(ast: &Ast) -> u32 { - 0 -} - -#[derive(Copy, Clone, Default, PartialEq)] -struct NodeId(usize); -impl fmt::Debug for NodeId { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "NodeId({})", self.0) - } -} - -#[derive(Debug, Default)] -struct Node { - parent: Option, - data: Option, - left: Option, - right: Option, -} - -impl Node { - fn set_left_child(&mut self, id: Option) -> Option { - let old = self.left; - self.left = id; - old - } - fn set_right_child(&mut self, id: Option) -> Option { - let old = self.right; - self.right = id; - old - } -} - -#[derive(Debug)] -struct Tree { - nodes: Vec, - root: NodeId, -} - -use std::fmt; -impl fmt::Display for Tree { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fn print_node(f: &mut fmt::Formatter<'_>, tree: &Tree, id: NodeId) -> fmt::Result { - //dbg!(id, tree.get_node(id)); - match tree.get_node(id).data { - None => (), - Some(Token::Num(n)) => write!(f, "{}", n)?, - Some(Token::Add) => { - print_node(f, tree, tree.get_node(id).left.unwrap())?; - write!(f, "+",)?; - print_node(f, tree, tree.get_node(id).right.unwrap())?; - } - Some(Token::Mul) => { - print_node(f, tree, tree.get_node(id).left.unwrap())?; - write!(f, "*",)?; - print_node(f, tree, tree.get_node(id).right.unwrap())?; - } - Some(Token::Open) => { - write!(f, "(",)?; - } - Some(Token::Close) => { - write!(f, ")",)?; - } - Some(Token::Space) => { - write!(f, " ",)?; - } - }; - Ok(()) - } - print_node(f, self, self.root) - } -} -impl Default for Tree { - fn default() -> Tree { - Tree { - nodes: vec![Node::default()], - root: NodeId(0), - } - } -} - -impl Tree { - fn get_node(&self, id: NodeId) -> &Node { - &self.nodes[id.0] - } - fn get_node_mut(&mut self, id: NodeId) -> &mut Node { - &mut self.nodes[id.0] - } - fn add_node(&mut self, n: Node) -> NodeId { - self.nodes.push(n); - NodeId(self.nodes.len() - 1) - } -} - -#[derive(Debug, Default)] -struct Parser { - tree: Tree, - cur: NodeId, - debug_tokens: Vec, -} - -impl Parser { - fn add_left_child_cur(&mut self, mut n: Node) -> NodeId { - n.parent = Some(self.cur); - let id = self.tree.add_node(n); - self.cur_node_mut().left = Some(id); - id - } - fn add_right_child_cur(&mut self, mut n: Node) -> NodeId { - n.parent = Some(self.cur); - let id = self.tree.add_node(n); - self.cur_node_mut().right = Some(id); - id - } - fn cur_node_mut(&mut self) -> &mut Node { - self.tree.get_node_mut(self.cur) - } - - fn cur_node(&self) -> &Node { - self.tree.get_node(self.cur) - } - fn set_cur_data(&mut self, t: &Token) { - let cur = self.cur_node(); - let cur_id = self.cur; - if cur.data.is_some() { - match cur.right { - Some(node) => { - // Create a new node, stick it in `right` and reparent the previous node. - let id = self.tree.add_node(Node { - parent: Some(self.cur), - ..Node::default() - }); - self.set_cur_node(id); - self.tree.get_node_mut(cur_id).right = Some(id); - self.cur_node_mut().left = Some(node); - } - None => { - let id = self.add_right_child_cur(Node::default()); - self.set_cur_node(id); - } - }; - } - - self.cur_node_mut().data = Some(*t); - } - fn set_cur_node(&mut self, id: NodeId) { - assert_ne!(Some(self.cur), self.cur_node().parent); - self.cur = id; - } - fn set_cur_to_parent(&mut self) { - match self.cur_node().parent { - Some(parent) => self.set_cur_node(parent), - None => { - let id = self.tree.add_node(Node::default()); - self.cur_node_mut().parent = Some(id); - let old_id = self.cur; - self.tree.root = id; - - self.set_cur_node(id); - self.cur_node_mut().left = Some(old_id); - } - } - } - fn add_token(&mut self, t: &Token) { - //TODO(wathiede): we seem to be building the tree backwards so that walking the tree works - // right-to-left instead of left-to-right. - self.debug_tokens.push(*t); - match t { - Token::Num(_) => { - self.set_cur_data(t); - self.set_cur_to_parent(); - } - Token::Add => { - self.set_cur_data(t); - let id = self.add_right_child_cur(Node::default()); - self.cur = id; - } - Token::Mul => { - //dbg!(&self); - self.set_cur_data(t); - let id = self.add_right_child_cur(Node::default()); - self.cur = id; - } - Token::Open => { - let id = self.add_left_child_cur(Node::default()); - self.cur = id; - } - Token::Close => self.set_cur_to_parent(), - Token::Space => unreachable!("spaces should be filtered"), - }; - } - fn eval(&self) -> u32 { - dbg!(&self.debug_tokens); - dbg!(format!("{}", self.tree)); - fn eval_inner(tree: &Tree, id: NodeId) -> u32 { - match tree.get_node(id).data { - None => panic!("empty node"), - Some(Token::Num(n)) => n, - Some(Token::Add) => { - let l = eval_inner(tree, tree.get_node(id).left.unwrap()); - let r = eval_inner(tree, tree.get_node(id).right.unwrap()); - dbg!(l, r); - dbg!(l + r) - } - Some(Token::Mul) => { - let l = eval_inner(tree, tree.get_node(id).left.unwrap()); - let r = eval_inner(tree, tree.get_node(id).right.unwrap()); - dbg!(l, r); - dbg!(l * r) - } - Some(Token::Open) => panic!("("), - Some(Token::Close) => panic!(")"), - Some(Token::Space) => panic!(" "), - } - } - eval_inner(&self.tree, self.tree.root) - } -} - #[aoc_generator(day18)] fn generator(input: &str) -> Vec> { input.split('\n').map(lex).collect() @@ -283,7 +57,7 @@ fn lex(input: &str) -> Vec { b'+' => Token::Add, b'*' => Token::Mul, b' ' => Token::Space, - c @ b'0'..=b'9' => Token::Num((c - b'0') as u32), + c @ b'0'..=b'9' => Token::Num((c - b'0') as u64), c => panic!(format!("unexpected char '{:?}'", c)), }) // Ignore spaces @@ -291,15 +65,74 @@ fn lex(input: &str) -> Vec { .collect() } -fn parse(tokens: &[Token]) -> u32 { +fn parse(tokens: &[Token]) -> u64 { + /* let mut p = Parser::default(); dbg!(&p); tokens.into_iter().for_each(|t| p.add_token(t)); p.eval() + */ + let mut stack = vec![Vec::new()]; + let mut cur_stack = 0; + tokens.iter().for_each(|t| { + match t { + Token::Num(n) => match stack[cur_stack].last() { + Some(Token::Add) => { + stack[cur_stack].pop(); + if let Some(Token::Num(left)) = stack[cur_stack].pop() { + stack[cur_stack].push(Token::Num(left + n)); + } + } + Some(Token::Mul) => { + stack[cur_stack].pop(); + if let Some(Token::Num(left)) = stack[cur_stack].pop() { + stack[cur_stack].push(Token::Num(left * n)); + } + } + None => stack[cur_stack].push(*t), + c => { + dbg!(&c); + } + }, + Token::Add => stack[cur_stack].push(*t), + Token::Mul => stack[cur_stack].push(*t), + Token::Open => { + stack.push(vec![]); + cur_stack += 1; + } + Token::Close => { + // Take the result of this parenthetical group and push it on to the stack one + // level below. + assert_eq!(stack[cur_stack].len(), 1); + let t = stack[cur_stack].pop().unwrap(); + stack.pop(); + cur_stack -= 1; + stack[cur_stack].push(t); + // If the stack has 3 things, it was waiting for this result. + let len = stack[cur_stack].len(); + if len >= 3 { + let s = &mut stack[cur_stack]; + match (s.pop(), s.pop(), s.pop()) { + (Some(Token::Num(right)), Some(op), Some(Token::Num(left))) => match op { + Token::Add => stack[cur_stack].push(Token::Num(left + right)), + Token::Mul => stack[cur_stack].push(Token::Num(left * right)), + d => panic!(format!("unexpected op {:?}", d)), + }, + d => panic!(format!("unexpected trio from on stack: {:?}", d)), + } + } + } + Token::Space => unreachable!("no space should be present"), + }; + }); + match stack[cur_stack].last() { + Some(Token::Num(n)) => *n, + d => panic!(format!("Unexpected stack contents: {:?}", d)), + } } #[aoc(day18, part1)] -fn solution1(tokens_list: &[Vec]) -> u32 { +fn solution1(tokens_list: &[Vec]) -> u64 { tokens_list.iter().map(|tokens| parse(tokens)).sum() } @@ -325,15 +158,415 @@ mod tests { #[test] fn part1() { + // 1106240272 too low for (input, want) in vec![ + ("1 + 2 * 3", 9), + ("(1 + 2) * 3", 9), + ("((1 + 2) * 3)", 9), + ("1 + (2 * 3)", 7), + ("(1 + (2 * 3))", 7), ("1 + 2 * 3 + 4 * 5 + 6", 71), + ("(1 + 2 * 3 + 4 * 5 + 6)", 71), ("2 * 3 + (4 * 5)", 26), ("5 + (8 * 3 + 9 + 3 * 4 * 3)", 437), ("5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))", 12240), ("((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2", 13632), + ("((9 * 7 + 6 + 7 * 9 + 2) * 4 + 3 + 4 + 4 * 6) * 8 + (4 + (8 + 2 * 6 * 4 * 3)) + (5 + 2 * 6 * (4 * 5 + 4 + 2)) + 4 * (6 + 3 * (2 * 2 * 6 * 3) + 8 + 4 * 5)", 1740572064000), ] { - dbg!(&input); - assert_eq!(parse(&lex(input)), want, "{}", input); + let got = parse(&lex(input)); + eprintln!("got {}, want {} for {}", got, want, input); + assert_eq!(got, want, "got {}, want {} for {}", got, want, input); + } + let input = r#"1 + 2 * 3 + 4 * 5 + 6 +2 * 3 + (4 * 5) +5 + (8 * 3 + 9 + 3 * 4 * 3) +5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4)) +((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2"#; + assert_eq!(solution1(&generator(input)), 71 + 26 + 437 + 12240 + 13632); + } + + #[test] + fn comprehensive() { + let mut ts = vec![ + ("(7 * (3 + 8 + 8 + 7) + (6 + 8 * 2 + 5 + 2 * 6) * (5 + 2) * 9) + ((7 * 4 + 8) * 6 * 8 + 9) * 7 * 2 * 2", 9896040), + ("6 * ((9 + 4) * (6 * 7 + 5 + 8 * 2))", 18720), + ("7 * 8 + 2 + 8 * (8 * 4) * (4 + 8)", 48384), + ("(9 + 3 + 2 * 5 * 8) + 9 + 5 * 2 * 5 * (6 * 6 * 4 + 6 * 9 * 3)", 55792800), + ("6 * 6 * 4 * (6 + (3 * 9 * 2) + 9 + (4 + 7 + 7))", 12528), + ("7 * ((4 * 6 + 4 + 6 * 8 + 6) + (2 * 7 * 8 + 5 * 3 + 7) + (5 * 5 * 5 * 7) + 8 * 7)", 176351), + ("(8 + 9 * 7 * 9 + 6) + (7 + 5) + 6", 1803), + ("5 * (6 * (3 + 2 + 9)) + 8 + 3 + 5 * (4 + 3 * 8 * 8 * 6 * 2)", 2688000), + ("4 + (3 + 4 * (4 + 9 + 3) * (4 * 8 * 4 * 9))", 129028), + ("4 * 4 * 6 * 2 + ((8 * 4 * 3 + 6) * 5) + 6", 139008), + ("(8 * (8 + 5 + 5 * 7) * 9 + 2 + 9) * 4 + 9 * ((3 + 3) + 8) + 9", 6027840), + ("((9 + 8 * 3 + 2 + 9 + 8) * 3 + (3 + 7 * 6) * 9 * 2) + 3 * 7", 2968833), + ("5 + 5 * (5 * (6 + 6 + 6 + 7) * 7 + (9 * 4) * 4 * (8 * 9))", 15480000), + ("7 * (2 * 7 + 3 + 5 + 5 * 2) + 4 + 3 * 3 + 5", 4872), + ("(4 + 5 * (2 * 4 + 5 * 2 * 7 + 5) + 2 + 9) + 4 + 9 * 9 * 3", 108000), + ("7 * 6 + (6 * 2 + 4 + 5 * 8) + (6 * 2 * (4 * 7 * 2) + 9 * (5 * 2 * 4) + (3 + 2 * 5)) * 8", 2869104), + ("2 + ((9 * 3 * 3 * 3) * (5 * 9 + 6 + 7 + 6 + 8) * 3)", 131222), + ("7 * ((9 + 7 + 4 * 3 * 4 + 4) + 4 * 3) * 5 * 3 * 7", 1067220), + ("8 * (3 + 5 * 9 + 4) * 6 + 4", 8320), + ("7 + 6 * 7 * ((7 * 6 * 2) * 3) * 5 * 7", 802620), + ("8 + 5 * 4 * (3 + 5 * (8 + 5 * 2) + 6) + 6", 13624), + ("4 * 8 + ((3 * 5 * 4) + 7) + (4 * 2)", 332), + ("((5 + 8 + 7 + 6 * 6 + 3) + 4 * 3 * (5 * 2) * 5 * (2 * 9)) + 6 + 3 * (2 * (2 + 4 + 8) * 4) + (9 + 3 + 6 * (9 + 5 * 6 * 3 * 8 * 5) + (4 * 6) + (6 * 3 + 2 + 8))", 117846779292), + ("(3 + 4 + 8) + 6 * (7 * 6 * (9 * 3 * 5 * 5 * 4 * 5) + (6 + 4) * (5 * 2 * 3 + 3) + (2 * 7)) + 2 * 4", 3527082888), + ("6 * (6 * 9 * (3 * 9) * 4 + 9) + 6", 113760), + ("4 + 6 * 7 * ((3 + 5 + 3) * (6 + 3 * 9 + 6 * 8 * 9) + 6 * 4) * 8", 239648640), + ("5 + (6 + 9 * (7 * 8 * 8 * 3 * 4) + 2) * 4 * 2", 645400), + ("(2 * 7 * 6 + 9 + (3 * 6 + 4 * 7 + 5) + 8) + 7 + 7 * 8", 43008), + ("2 + (6 + 4 + (5 + 5) * 7) * 2 + 7 * 5", 6390), + ("4 + 9 * 3 + 8 * 6", 858), + ("(5 + 5 + 9 * 8 * (4 * 5 + 6 + 3 * 8 * 3) + 6) + 9 + 9", 205218), + ("(8 * 4 * 7 + 9 + 6 * 9) * (9 + 2 * 2) + 3", 158400), + ("((9 * 4 + 8 + 4 * 2 + 2) * 3 + (6 + 9 * 5 * 4) * 4 + 6 * 5) * 5 * 3 * 5 + (3 + 5 * 4)", 4843152000), + ("5 + (5 * 3) * (2 + 8) * (3 + 6 + 4 * 6 + 7 + 7) * 5 * 7", 1820000), + ("6 * 6 * 7 * (5 * 4 + 2 + 6 + (8 + 6 + 4 + 9 * 5))", 185220), + ("2 * 9 + (2 * (8 * 7 + 6 + 5 + 3) + 2 + 9 * (3 * 9 * 4 * 7 * 7 + 5) + 3) + (4 + 6 * 4 + 6)", 6497918), + ("(9 + (8 * 8 + 2 + 2 * 6 + 6)) * 8 + 4 + 3 + (9 + 3 + 9 + 9 * 4 * 8) * 2", 2263950), + ("8 * 4 * (4 * (3 + 7 * 7 + 3) + 8 * (5 + 2 + 3) * 2) + 9", 276768), + ("5 + (6 * (3 * 3 + 7 * 3) * (4 * 4) + 2 * 4 * 4)", 155525), + ("3 + (5 * 8 * 9 * 3 + 9 * (6 * 7)) * 9 + 3", 2177316), + ("3 * (9 * 3 + (5 + 4 * 7 + 3 + 8)) + 4 * 2 * 3", 26802), + ("8 * 9 + 6 + (7 + 7 + 9 * 8 * 5 * 6) * 5", 221400), + ("(8 + 9 + 3 + 7 * 7) + 2 + 9 + (8 + 7 + 4 + 2) + 9", 230), + ("4 * (2 * (7 * 4 + 2 + 9 + 6 + 7) + (4 + 2) * 3 + 9 + 6) + 6 * 4 + 7 * 5", 1601160), + ("(3 * 4 + (5 * 8 * 2) * (7 + 8)) + 7 + 8 + 5 + ((6 * 9) * 4 * 5)", 4880), + ("4 + ((9 + 9) + (7 * 8 + 2 * 8 * 2) + 9) + 2 + 7 * 2", 2320), + ("8 * 3 * (9 + 5 + 8 + 5)", 648), + ("4 + 4 + (6 + 2 * 7 + 9 + 6 * 5)", 888), + ("((8 + 3 * 8 * 2) + 7 + 7 * (7 * 7 * 7 + 3) * 9 * (9 * 4 + 7)) + 4 + 6", 82952110), + ("6 + (7 * 2 + 4 + 5 + 4) + 9 + ((7 * 9) * 7) * 5", 2805), + ("(7 * 3 * 2) * ((9 + 6 * 2 * 6 * 3) + (6 * 7) + 3 + (6 + 5 * 5 + 4 + 9 * 6) * 4 + 9) + 4 + 7 + 6", 968772), + ("9 * (3 * (9 + 8)) * 4", 1836), + ("6 * (4 * 2 * (9 * 5 * 4 + 7 + 9) + 6 + (3 + 6 * 2)) * 5 * (3 * (2 + 6 * 8 * 6 + 3 + 7) * 8 * 7 * (9 * 8 * 7 + 7 + 9) * 7) + 3 + 6", 442232672777280), + ("7 + 3 * ((6 * 3 * 9) + 3 * 9)", 14850), + ("7 * ((4 + 4 * 4 * 9 * 7) + 2 * 9) * 8 * 6 * 6 + 3", 54921888), + ("6 + 5 + (5 + 3 * (3 + 7 + 9 * 3) * 6) + 3 + ((2 * 3 * 4 + 4) * 6 + (3 + 3) + 2)", 3422), + ("9 + ((8 * 9 * 3 * 2) * 5 + 8)", 5625), + ("(2 + 7) * 3 * (8 + 5) + 9", 594), + ("4 * (5 + 4 + 6 * (9 * 4 + 8 * 4 * 7 * 3) * (4 * 4 * 6) * (9 + 7 + 8 * 4)) * (4 + 4 + 9 + 8) + 7 * 8 + 5", 2086844497920), + ("((7 * 4 * 4 * 3) * 4 + 2 * 2 + 2) * 9 + 9 * 8 + 9", 2467584), + ("4 + 6 + 2 * (5 + 3 + 8 * 4)", 768), + ("((7 + 6) + 3 * 3 * 5) * ((9 * 3 + 5 + 8) + (3 + 8 * 8 + 7 + 5 * 6) + 2 * 5 + (7 + 9 + 2)) + (4 * 2 * (5 + 8 + 5 + 3) * 5 + 6 * 2) + 6 * 5 * (2 * (9 + 4) * (7 * 8) * 8 + 7)", 980703360000), + ("6 + 5 + 5 + 2 * 5", 90), + ("5 + 5 + 8 * 8 + 2 + 6", 288), + ("(3 * (4 * 6 * 8 * 2)) + 3", 1155), + ("(5 + 6 * 3 + 5 * 2) * 5 * (3 * 5 + 2 * 7 * 9 * 3) + 5 * ((6 + 2 * 7 + 2 + 4 + 2) * 9 + 6) + 7", 6319295840), + ("(7 + 7 * 4 * 7) * ((8 * 5 * 9) + 6 * 9 + 3 * 3 * 9) * 8 * ((3 * 5 * 2 + 6 + 5) * 7 + (6 * 2 * 7 * 7) + 8 + 8 + 6)", 44742672898560), + ("(3 * 6 + 7 + 6 + 3 + 7) * 4 * 7 * ((9 + 3 + 6) * 5 + 3 + (5 * 7 + 4 + 5 * 2) + 5) * 5 * 9", 341356680), + ("7 * ((7 + 6 + 2 + 9) + 3 * 4 + 9 + 2 + 2) + 2", 3227), + ("3 * 8 * 2 * (6 * 2 * 2 + 4 * 8) + 8 + 7", 28368), + ("8 + 3 + ((4 * 6 * 5 * 7) * 9 + 9 + 8 * 4)", 87371), + ("(6 + 4 + (6 + 3 + 3 + 3) + 6) * 9", 279), + ("2 * 6 * (5 + 2) * (6 * 6 + 7 + 2)", 7560), + ("4 + (8 + 2 + 4) * 4 * 5 + (9 * 5 + 9) + 8", 10008), + ("6 * 3 * 9 + 6 + (2 * 4 * 3 + 2 * 5 * 3) * 6", 66420), + ("2 + (8 + 5 * 7 + 4 + 7 * (2 + 9 * 6 * 5 * 3 + 3)) + 9 * 4", 1853324), + ("(9 + (2 + 6 + 7 * 4 * 8) + 9 * 4 + 9) * 3 + 8 * 8", 569712), + ("2 * (9 * 5 * 9 + (8 * 9 + 5)) * 8 * 8", 696960), + ("3 + 6 + 2 * 3 * 9 + 9", 594), + ("8 * 7 + 8 * (5 + 6) * 5 + 4", 11880), + ("4 * (6 * 2 * (3 + 6 * 3) + 7 * 5 + 6)", 17952), + ("(7 * 3 * 7 * 4 * 3 * 2) * (9 + 8 * 9) + 9 * (4 * 5 + 3 + 5 + 9)", 50295168), + ("9 + 8 * 3 * 4 + (9 + 8 * 9) + (4 * (6 * 4 * 9 * 5 + 6 + 4) + 8 + 7 + (4 * 9))", 679371), + ("2 * (4 * (3 + 4 + 8 + 5) * 8 * 6)", 7680), + ("8 * (8 * 2 * 6 + 6 + 6) * 8", 18432), + ("(9 + 3 * 4 * 9 + 5 * 5) * 4", 13440), + ("(9 * 9 * 4 * 4 + (6 * 2) + (3 + 3 * 2)) + 3 + ((2 * 3 + 8 * 4 * 8 * 2) + 2 + 3)", 10488), + ("7 * (9 * (6 + 3 + 7)) * ((8 + 3 + 3 * 3 + 3 + 7) + 4 + 5 + 3 * (6 * 4 * 6 * 6 + 2 * 5) + (2 + 3 + 9 + 3 * 6 + 4)) + 6", 1159629408), + ("8 + 6 * (3 + 5 + 6 + 9) * 4", 1288), + ("(6 + 7 + 7 + 7 * 6 + 5) + 3 * 5 * 4 * 5 * 6", 180000), + ("(2 * 9 + 9 + 3 * 7 + 6) + 3 + 7 + 4 + 9", 569), + ("(7 + (8 * 7 * 4 * 7 * 2 + 4) + (5 + 2 * 2 + 2 * 2 * 6)) * 3 * 4 + (4 * 2 + 4 * 6 + 3 * (8 * 6 + 4 * 3 * 7)) * 6", 63692673912), + ("2 * (3 * (5 * 7 * 8 * 7 + 8) + (6 * 3 + 5) + 5 + 9)", 25572), + ("8 * 4 + ((7 + 2 + 8) + (2 * 8 * 4 * 4 + 4 * 7) * 2) * 5 * 4", 1152960), + ("2 * 6 * 2", 24), + ("2 + (2 + 6 * 5 * 9) + ((8 + 2 * 6 * 5 * 5) * 7 + 3) + 3", 15365), + ("((9 + 4 + 6 * 3 + 9) * 5) * (7 * 2 * 7 * 5 * 2) + 7 + 9 + 7", 1143420), + ("2 + 2 * 8 + 8", 64), + ("4 + 6 + 4 * 7", 98), + ("4 + 5 + 5 * 8 * (8 + 4 + (2 * 8 + 9 * 9 + 4 + 5))", 69888), + ("(7 + 2 + (8 * 4 * 2 + 9 * 6) * 4) * 2 + (9 * 2 * 8 * 9 * 4)", 43998024), + ("4 + 9 + 6 * (4 * 6) + 7", 589), + ("6 + 4 + 8 * (7 * 9 + 7)", 2016), + ("3 * 2 + 2 + 9 + (2 * 9 * 2 * 8 * 2 * (2 + 8 + 9 * 9 + 7)) * 7", 3677457), + ("9 + 9 + 5", 23), + ("(2 + 3 * 3) + 7", 22), + ("(9 * 7 + (8 + 8 * 6) + 2 * 7 * 3) + 6 * (5 * (2 + 9 + 9 + 6) + 6) * 8 * (4 + 4 * 6 * 5 + 5) * 8", 97571635200), + ("7 + 4 + (4 * 2 + (2 * 7 + 2 + 4 + 2 + 5) + 9 * (9 * 7 + 7)) + 9 + 7 + (8 + 9 * 7 + 2 + (7 * 8 * 5 * 4 + 6 + 8))", 111564), + ("(8 * 3) * (9 + 2 * 7 * 7 + 7) * 6 * 8 + 8 + (9 + 9 + 3 * 5 + 3)", 28562688), + ("4 * 5 + 2 + 4", 44), + ("((7 + 3 * 8 + 3) * 8 + 4 + 4 * 4 + 8) * 5 + 9 * (3 * 9 + 8 * 7 * 9 * 4) + 7", 3802149120), + ("(8 + 6 + 7 + 9) + 8 * 6 * (5 + 2 + 3) * 8", 18240), + ("(9 * 8 * (6 * 5) + 9) + 4 + 8 + 8 * 8", 22624), + ("(4 + 5 * 9) * 7 + 7 * 6 + 8 * (2 + 5 * 8)", 889056), + ("(4 + 3 + (6 + 2 + 2 + 6 * 6 * 2) * 4 * 2 * 9) + 3", 14331), + ("8 * (5 + 8 + 2 * 7) + 2 + ((5 * 6 + 4 + 7 + 6 * 5) * 7 * 3 + 8)", 355056), + ("2 + 5 + (6 * 3 + 2) + 8", 45), + ("2 + 9 * 6 * 5 + 5", 660), + ("3 * 3 + 7", 30), + ("(9 + 4 * 9) + 5 + (2 * 6 * (6 + 9) + 2 + 6) * 2 * ((9 * 6 + 7 * 3) + 5 * 2 + 3 * 9)", 12751920), + ("2 + 6 + ((6 * 9 * 9 * 8 * 9) + 9) * (5 + 2 * 5 * (3 + 5 * 8 * 5 * 2 * 9) * 8) * ((7 + 9 + 3 + 6 + 5) * 4 * 5)", 33877509120000), + ("3 * 9 * (5 + (3 * 4 * 2 + 8) + 5 * 3) + 4", 10638), + ("9 * (9 * 3 + 3 + 4 + 7 + 4) + 3", 1728), + ("2 * 9 + 3 * 9 + 5 + 9", 552), + ("(6 + (6 * 6 * 6 + 7 + 7 + 5) * 5) + 3 + 4 * 9", 40833), + ("(2 * 8 * 8 * 6 * 8) + (5 + (5 * 6) * (8 + 5 + 7 * 7 + 2) + (6 * 4 + 7 + 5) + (3 + 5 + 8 + 6)) * 8 + ((8 * 3 + 3 * 7) * 4 + (3 * 8 * 4))", 557018992), + ("4 + ((9 * 2 * 9 * 9 * 7 + 5) * 6) * 7 * 7 + 5 * 8", 70546560), + ("(3 * 6 + 6 * (5 + 6 * 4 * 6 + 2 + 9)) * 9 * 9 + (2 * 7 * 2 * 5)", 36110448), + ("6 + 2 + (8 + 6)", 22), + ("6 + 3 * (3 + 3) + 8 * (9 * 6)", 6804), + ("(2 * 8 + 4 + 5) + 7", 41), + ("7 + (2 * 9 * 5 * 6)", 547), + ("2 + 9 + ((7 + 3 + 3 * 9) * 6 + (5 + 2 + 8 + 5 * 6) * 7 + 8)", 221141), + ("((4 + 9 + 8 * 6 + 8 * 9) + 8) * 6", 15924), + ("9 * (9 * 3 + (3 * 8 * 8 * 7) * (4 + 8) + 8 * (5 * 3 + 2 + 4 * 3))", 294588900), + ("9 * (7 + (3 * 5 * 5 + 3 * 7)) + (5 * 3 + (4 * 7 * 7 + 8) * (3 * 7 * 5 * 6) * 8) * 5 + (2 * 7) * 4", 7291745748), + ("4 * ((2 + 3 * 2 * 2 + 3) + 4 * 4 * 4 * 5 + (3 + 3 * 9 * 9 + 7)) * 9", 27029376), + ("8 + 7 * 4 * 3 * (5 + 9 + 8 * 7 * 3)", 83160), + ("9 + (4 * (2 * 6 + 7) + 5 * 4 + 8 + (6 + 7 * 8 * 2)) + 9 + 5 + 8", 27311), + ("3 * ((5 * 2 * 8 * 7 * 2 + 4) * (3 * 3 * 5 + 2) + 7 + 8) * 8 * 2 + 3", 31449600), + ("(8 * 2 + 5 + (4 * 9 * 7)) * 5 + (9 * 8) * (5 * (7 * 8 + 4 * 4) + 3)", 270427080), + ("((7 * 6 + 9 + 7 + 9 + 9) * 2 * 8 + (6 + 4 * 7 * 2 * 2) * 7 + (2 + 9 + 9 + 5 + 4)) * 5 * 2 + 7", 261273600), + ("7 + 2", 9), + ("4 * ((2 * 6) * 5 * 5 + 9 * (7 * 7 * 3 + 8)) + 2", 1811048), + ("6 * 8 + 5 + 4 * (5 + 8)", 1326), + ("4 + 6 * (4 * 5 * 3 * 5 * 5 * 6) * 8 * 5", 3600000), + ("7 + ((6 * 6 + 2) + 7 * 7 + 7 * 9 * 6) + 6", 41593), + ("(7 + 3 * (2 * 5 + 3 * 9)) + 2 * 2", 2884), + ("6 + 3", 9), + ("2 * 8 * (3 + 8 * (4 + 6 * 4) * 8 * 2)", 112640), + ("8 * ((4 + 8 * 5 + 7) + 6 + (4 + 8 + 4 + 9 * 7 + 9) + 2) + 5", 4456), + ("(7 + 7 + 2 + 3 + 6 * 3) * ((7 + 5 + 8 + 5 * 6) + 4 + 6 * (3 + 3) * (4 + 6 * 9 * 6 + 4) * 7) * 3 * 9 + 5 + 4", 24494400000), + ("5 * 7 * (5 * (2 + 5 * 7 + 7 * 5) + 9) + 3", 87430), + ("8 + 2 * 4 * 3 + (8 + 3 + 4 + 3 + 2 * (4 * 5)) * 5", 80600), + ("3 + (8 * 3) * 7 + 4 * 5 * 2", 2970), + ("(7 * (7 * 2 * 7 * 3) * 3 + 2 + 7 * 6) * 4 * 6 + 6 + 6", 10668672), + ("(5 + 2 + 2 * 8 + (2 * 9 + 7 + 3) + 5) * 9", 4131), + ("(6 + (7 + 8 * 2 + 9) + (7 * 3 * 4 * 5) + 6 * 3 * 4) + (3 * 2 * 5)", 7194), + ("4 + 7 + (8 * 7 + (5 * 4))", 227), + ("8 * 2 * 5 * (9 + 4) + (3 * 7)", 2720), + ("(3 + 4 + 8 + 6 + 2) * 9 + 6 + 6 + 3", 552), + ("(9 + (3 * 4 * 5 * 8 + 5) + (5 + 8)) + 5 * ((2 + 5) + (7 + 9) * 2) * (6 * 3) + 8", 965172), + ("9 * (3 + 9 + 8 * (9 + 7 + 9 + 8 * 6) + 8 * 8) + 2", 296658), + ("7 * ((9 * 2 + 8 * 4 + 7) * 4 + 3 + (5 * 3 * 5 + 3 + 4)) * 5 * 7", 45356850), + ("5 + 2 + (8 * 8) + 8", 79), + ("4 * (4 * 9 + (7 * 6 + 2 * 2 + 5 + 8) * 9 + 7) * 3 * 7", 4564224), + ("9 + 9 + (4 * (8 + 2 * 5 * 9 + 9 * 2) * 4 * 7) + (6 + 2) * ((8 * 7) + 9 * (7 + 7 * 7) + 2 + 5 + 2) + 6", 1403518586), + ("9 + 4 + (3 * 9 * 3 * 9) + (3 + (2 + 9 + 9 + 8 + 7) + 5 + 9 * 3) * 7 * (4 + 7 * 8 + 7 * (4 * 2 + 5 * 8 + 9 + 8) + 3)", 729144570), + ("6 + (2 + 6) * (6 * 2 * 2 + 7) * 4 * 6", 36288), + ("6 * (2 + (6 * 7 + 7 * 9) * 6) * 3 * 8 + 3", 900504), + ("8 + (5 + 4 + 6)", 23), + ("9 + 2 * (5 * 5 * 5) * 2 * 5", 13750), + ("4 * 4 * ((3 * 3) * (9 + 7 + 5) + 5 + 9) + 7 * (4 * 2 * 4) * 7", 1154048), + ("((4 * 5 * 7 * 7 + 3) * 9) * (6 * (7 * 8 * 7 + 3 + 7) + (4 * 2 + 3 + 3) * 4 + 6)", 743904000), + ("4 * 2 + 3 + 2 * (2 + 2 * 2 * 8)", 1792), + ("4 + ((3 + 8) * 7 + 2 + (9 + 4 + 9 + 3 + 4 + 6) * (7 * 5 + 8)) + 4 + 5 * 8 + 2", 440570), + ("(5 * 2) + 3 + (3 + 9) + 4 + 4 * 5", 165), + ("6 + (5 + 8 + 6 + (7 + 5 + 9)) + (3 * 5 + 8 * 3 * 4) * 4 + 4 + 5", 6682), + ("((7 + 4 * 6) * 7 * 2 + 6) * 7 + 8", 55440), + ("7 * 5", 35), + ("2 + 9 * 4 + 9 + 4 + (8 * 9)", 979), + ("5 + 5 * ((5 + 6) + 2 * 4) * (8 + 8 * 5) + 3", 43160), + ("5 * 5", 25), + ("4 * 3 * 4 + 3 * (7 * 9) + 4", 5628), + ("4 + 4 * (8 * 3 + 2 * 8 + 2) + 4 + 3", 3256), + ("(8 + 5 + 4 * 4 + 6 * 9) + 8 * 6 * 3", 27684), + ("8 + 6 + 3 + ((2 * 9 + 2) + (7 + 7 + 3)) + 6", 62), + ("(4 + 5 + 8) * 8 + (7 * 9 + 3 * 3 + 9 + (8 + 5 + 7 + 3 + 9)) + (3 * 3) * 8", 504968), + ("(4 + 4 + 4 * 6 + 4 + 9) * 6 * ((8 + 6 + 3 + 2 * 8 + 2) * 4 + 6 * 8 * 7) * 5", 727776000), + ("6 * 6 + 3 * (2 + 7 + 3) * 4 + 5", 5832), + ("((2 * 4 + 3 * 3 * 9 * 3) * 7) + 2 + 8 + 6 * 2", 15908), + ("5 * (5 * 4) + 6", 130), + ("((7 + 6) + 7) + 3 * 2 * 9 * 6 + 4", 4140), + ("6 + 8 + ((4 * 9 + 5) * 4) * (5 + 7 + 8 * 8 * 2) + 9", 78302), + ("8 * 4 * 8 * 9 * 2", 4608), + ("5 + 2 + (8 + 9 * 6 * 7 * 6) * 8", 34328), + ("6 * (9 * 5) + (5 + 2 + 6 * 8) * 6 * 6 * (4 + 7 + 8 * 8)", 4891968), + ("2 * 3 * 6 * 8", 288), + ("3 + (4 + 5 * 8 * 8) * 2 * (9 * (5 * 3 + 8 + 6) * 2 + (5 * 7 * 3) * (4 + 5) + 7)", 1516609440), + ("6 * (5 * 4) * 5 + 4 + (6 + 2) + 6", 2760), + ("2 * (4 * (7 + 2 + 3 + 3 * 8) * (9 + 3 * 3) + (6 * 8 * 5 * 7) + (6 + 5) + 7) * (3 + 8 + (5 + 4 + 8 + 6) * 3 + 2 + 3) * 8 + (3 * 3) * 9", 69275658240), + ("(5 + (4 * 8 * 7) + 7 * (7 * 9 + 2 + 5 + 6)) + 4", 36348), + ("6 + ((3 + 9) * 4)", 54), + ("9 + ((4 + 4 + 5 * 6) * 8) * 2", 1266), + ("(4 + 2) * 3 * 3 + 3", 108), + ("5 + 2 + (8 + 7 + 5)", 27), + ("6 + (7 + 4 * 9 * (6 + 8 * 8 + 3) * 8)", 121974), + ("3 + 3 * 6 * 3 + (4 * (2 + 6 * 7) * 8)", 64620), + ("7 * 5 + 8 * 7 + (9 + 4 * (7 + 6 + 2 * 7 * 9) + 9 + 9 * 4) + (3 + 6 + 5 * 6 * 4 + 9)", 4656925), + ("5 + (9 * (5 * 7 * 6 * 8) + (8 * 3) * 6 + (2 + 7 * 8)) * (9 + (5 + 7 * 2 * 6 + 9 + 7) + 4 + 8 * 3) * 7", 13791139677), + ("(6 + 7 * 7 * 9 * 4) * 3 + (5 + 7) * 7 * 5 * 6", 10319400), + ("(9 + 6 * 5 + 3) * (2 + 6 + 6) + 4 * 6 + 3", 19440), + ("5 + 8 + ((9 + 8) * (3 * 3 + 8 * 8) * 2 + 3) * 6 * 4", 538872), + ("((3 + 9 * 2 * 8 * 7) * 7 * 8 + 3 + 7) * (8 * 9) * 5", 60963840), + ("5 + 3 + (4 * 4 * (8 * 8 + 4 * 4) + 4 + 5 * 6) * 4 + 2 + 7", 490568), + ("5 + ((6 + 4 + 9 + 3) * 6 + (2 + 4 * 9 + 4 + 7 + 7)) + 4 + 9 * 8", 29712), + ("2 + 4 * 7 * 5 * ((5 + 4 + 6) + 4 * 4)", 15960), + ("8 * 6 + (4 + 8 * 5 * 6 + 4 * 9) * 9 + (2 + 8)", 821712), + ("((8 + 3 * 2 * 6) * (7 + 8 * 8) * 9 + (2 + 5) + 4) * (2 * 9 * 5 + (9 * 4 * 2 + 7 + 8) * 2 + 2) * 6", 84441139200), + ("4 * ((5 * 5 + 6 * 8 * 5 * 9) + 4 * (3 + 7 * 6 + 4) * 4) + 2 * ((9 + 8 + 9) + 9 * 2) * 8 + 4", 26616582720), + ("2 * 8 * 6", 96), + ("(7 + (7 + 8 * 9) * 7 + (5 * 8 * 6 * 9 + 6 * 4)) + ((5 + 9 * 6 + 7) + 8 + 7 + (8 * 7 * 4 + 5 + 2) * 5 + (9 + 3 + 9 * 2 * 6 * 3)) * (4 + 5 * 4) + (8 * (5 * 5) * 9 * (3 * 3) + 5) * 4", 268963975728), + ("(6 + 5 + 5 * 5) * 4 + ((8 + 6 + 8) + 5 + 5 + 7 * 9)", 28400), + ("9 * (9 * 2 + 4 * 2 * 4)", 3888), + ("4 + (6 + 2) * (4 + 2 + 2 * 5) + 2", 504), + ("5 * (6 + 8 + 5 * 2 * (7 * 2 + 2))", 5320), + ("((7 + 5) * 2 * (3 * 5 * 9)) + 7 * (7 * 5 + 9 * 9 * (5 * 9))", 128873430), + ("7 + 5 * (2 * 3 * 4 + 9 * 7 * 9) + (2 + 8 + (3 * 6) * 7 * 7 * (5 * 8 * 7 + 8 * 6 * 9)) * 5", 2667462840), + ("9 * 3 * ((9 + 7) * 7 * (2 * 9 + 5 * 9 * 7 + 8) + 6 * 6 + 6) * (9 + 7 + 6 + 9 * 7)", 29812841856), + ("8 + 9 * 4 * ((7 * 3 + 6 + 6 * 7 + 9) + 8 * 5 * 2)", 1147840), + ("3 * (3 * (5 + 5 + 5 * 2))", 270), + ("4 * 4 * 8 * 6 + (3 + (5 + 5 + 5 + 6 * 6) * 8 * 9 + 9) + 3", 2378880), + ("(3 + 8) + 4", 15), + ("6 + 5 + 3 + ((2 + 5 + 6) + (9 + 5 * 4 * 9) + 6 * 7 + 5)", 6290), + ("(6 * 8 * (2 + 2 + 8 + 8 + 2) + 7 + 6 * 3) + ((7 * 3 * 9) + 2 * 4 * 4 + 2) + 5", 9629), + ("6 * ((6 * 8 + 3 * 9) + 2 * 9) + 3 * (6 + (3 * 7 * 4) + 4 * (6 * 8 * 3 * 7 + 3 * 8) * 6 * 7) * 6", 8787467243520), + ("5 * 8 * (7 * 7 + 4 * 7) + (2 * 4 + (3 * 2 * 4 * 9) + 4 + 2)", 39640), + ("(3 * 8) + 3 + 6 + (3 * 3 + 9 * 6 * 8) + 3 + 5", 1769), + ("((6 + 5 + 7 + 3) * 7 + 9 * 5) + 9 + 2", 1691), + ("3 + 2 * ((9 + 9) * 8 + 5 * (6 + 4 * 6) + 4 + 7) + 9 + 4 * 4", 332540), + ("5 * 6 + (5 + 6 * 8 * 5 * (8 * 2 + 7) * (7 * 6 * 2 * 2 * 7 * 6))", 1117670430), + ("8 + 4 + 3 + (4 * 7) * 2 * (2 + (3 + 8 + 8 * 2 * 9))", 29584), + ("7 + 5 + 3 + ((9 * 9 + 2 * 8 * 6 + 5) * 2) + (3 * 7 + 6 * 4 * (8 * 6 + 8 + 8 + 7 * 3) + (9 + 3 * 8 * 6 + 4)) * (9 * 6 * 9 * 6)", 804159900), + ("5 + (2 + (6 * 3 * 3 + 9 * 8 * 8) + 3) + 9 * 6 + 6", 166116), + ("6 + (2 + (3 * 5 + 2 + 4)) + 7 * 9 * (8 * 9 * 6)", 186624), + ("((4 * 4) + 2 + 7 + (5 + 3 * 2 + 9 + 8 + 4) * 5) * (2 * (6 + 8 * 9 + 7) * 9 + (7 + 5 * 7) * 8) + 6 * 3 * 3", 3134855790), + ("(7 * 5) * (5 + 3 + 5)", 455), + ("(2 * 6 * 9 + 9 + 6) + 9 * 8", 2376), + ("6 + (9 + 6 + 7 * 7 * 3 + (9 + 8 + 2 * 3 + 4 + 7)) + 9 * ((2 * 5 + 4 * 6 * 6 * 7) + (6 + 5 * 4 * 5 * 8) + 9) + ((5 + 7) * 5 * 4)", 271231345), + ("(7 * 2 + 7 * 8 * (7 + 6)) * 2 * 2 * 2", 52416), + ("(6 + 5 * 2 + 3 + 5) * 8 + 4 + 2", 1540), + ("3 + 4 + 3 + 7 * ((2 * 8 * 8 * 3 + 4 + 4) * 8 * 2 * 9 + 4 + 9)", 8425472), + ("7 + (5 * (7 * 9 + 7 + 2 * 7) + 9 + 3 + 5 + (8 * 9))", 4862), + ("8 * (2 * (8 + 4 * 3) + 7 * 7 + 5 + 8) + 3 + 6 * 8", 110656), + ("(8 + 3 * 5) * 6 + 2", 440), + ("3 + 8 * ((3 * 8) + 8 + 5)", 407), + ("5 * 9 * 5 + ((5 + 6 + 7) + 4) + ((5 + 8 + 3 + 4 + 3) * 8 * 3)", 26055), + ("7 * (6 + 4 + (7 + 4 + 4 + 6) * 3 * 3 + 2) + 7 + 8 + 4 + 3", 3409), + ("2 + ((3 + 8) + 2 + 9 + 4 * 3)", 80), + ("4 + 9 * 3 + 9", 156), + ("(7 + (7 * 4 + 7) * (6 * 6 * 9 * 4) * (2 + 5 + 8 + 3)) * 3", 5878656), + ("(8 + 2 + 4 * 7 * 3) + 2 * ((6 + 2 + 2) + 7 * 8 * 8 * 5 * 8) + 7 + (5 + 8 + 2 * (9 * 9) + 3)", 13256952), + ("8 * 2 + 6 * ((5 * 3) * 6 * 2 * (7 * 2 + 4 * 4 + 9)) + 4", 6290176), + ("4 * 3 * (8 + 7 * (2 + 4 + 7 + 4 + 3)) * 9", 32400), + ("7 + (6 + (6 + 2) + 8 + 9 + 3) * (3 + 9 * (3 + 5 + 6 + 7 + 6) + (8 * 8 * 7) + 5 + 8) * 9 * 2 * 8", 34573824), + ("3 + 6 * (3 * 5) * (9 + 4 * 3) + (5 * 6 + 3) * 6", 68040), + ("6 + (5 * 6 * 7 * (2 * 4) * 9) * 7 * 7 * 6 * ((2 * 6 * 2 + 3) + 7 + 9 * 2 + 6 * 6)", 16222816512), + ("(4 * 4 * 2) * (4 + 3)", 224), + ("7 * 8 * 9 * 6 * 2 + (8 * (8 + 6 + 6) + 3 + 5 + 2)", 731808), + ("(9 + 2 + (8 * 9 * 5 + 7) + 3) * 9 * (7 + 8 + 3 * 4 + 5) + 8 * (5 * 5 + (4 + 5 + 5 * 3 + 8) * 4) + (7 + 3 + 7 + 4)", 4300031340), + ("8 * (2 * 2 + (8 + 7 * 9 * 2) * (8 * 2 + 5 + 4) * 9 + 8) * 6 + 3 + (4 * 3) * 7", 957057024), + ("(5 + 7 + 9 * 6 + 4) * 9", 1890), + ("(3 + (5 + 3 + 4) * 3) + 3 + 8 * ((5 * 8 * 6) + (8 + 6 * 4 * 4 + 8) * 8 + 2 * 4 + 7) + (2 * (5 * 5 * 3) * 2 * 9)", 5769120), + ("(8 + 2 * 8) + 9 * 8 + 7", 1335), + ("4 * (2 * 3 + 8 + 3 * 5) * ((3 * 3 * 8 + 7) * (7 + 5 + 8) * 6) + (9 * 5) + 8", 9101680), + ("7 * (6 * 3) + (7 + 8 + (2 + 5) * 3) + 7 + 6", 679), + ("5 + 9 * 2", 28), + ("9 * 2 + 8 * (3 * (6 * 7 * 7) * 8) + 9", 635850), + ("((2 + 8 + 7 + 6) + 4 * (6 * 5 + 7 * 4 + 5) * 8) * 9 + (7 + 2 * 5 * 5 * 3 * 3) + 3", 285114816), + ("6 + 3 * 3 + (8 + 4)", 135), + ("(8 + (8 * 2) + 4) * 5 * 4 + 5", 1260), + ("(5 * 5 * 5 * 8 + 8 + 7) + (6 + 9) + 4 * 3 + 4", 20258), + ("(3 + (2 * 9 + 2 + 9 + 4) + 2 + (5 + 3 + 2)) * 5 * 3 + 5", 2520), + ("6 + 3 * ((8 + 7 * 8 * 7 + 9) + 3 + 3 + 9 * (7 + 5 + 9) * 9) + 5 + (7 * 8 + (5 * 7 + 5 * 9 + 4))", 3341124), + ("(4 * 9) + 7 * 9", 387), + ("(3 + 7) + 2 + (5 * 2 * 4 * 6 + 5)", 452), + ("5 * 4 * 2 * ((9 * 4 * 7) * 2 * 3) + 3 + 6", 60840), + ("(5 + 2 * 7 * 7) * (4 * (3 * 8 * 2) * 3 * (2 + 3 * 8)) + 4 * 6 + 8 + 7", 165985932), + ("7 * 4 + 2 + (6 + 2 * 5 * 2 + 6 * 9) + 7 * 2", 40502), + ("8 + (4 * 4 * 7 * 9 + 5 + 6)", 2248), + ("(4 + 7 + 8 * 6) + (3 * 5 + 4) + 4", 145), + ("6 + 2 + 3 + 2 * 3 + 9", 156), + ("6 + ((7 * 6 + 5) + 4 + 9 + (5 + 6 * 6 + 5 * 2 * 9) * (2 * 9)) + 9 + 5 * 2", 81688), + ("8 + 3 * 4 * 3 * (3 * 9 * 2)", 7128), + ("9 * (7 * 7 * 4) + 3 + (9 + (6 + 6 + 2 + 3 + 5 + 6) * (3 * 7 * 9 * 3) * 6 + 8 * 3)", 7931853), + ("5 * (9 * 2 + (6 + 2 * 5) + 5)", 2115), + ("4 + 3 + 9 + 7 + 5 + (3 * (2 + 8 * 6) * 4 + 2)", 1108), + ("3 * ((2 + 5 + 2 + 6) + 3 + 4 + (7 + 9) * (7 + 8 * 4 + 9) * 3) + 9 + (8 + 6)", 66759), + ("8 + 4 * 4 + 7 + ((3 * 9 * 2 + 2 * 8) + (3 + 6 + 2 * 5 * 4 * 8) * 8 * 8)", 2015364), + ("4 + 4 * ((5 + 3 + 2 * 4 + 7 * 8) * (5 * 6 + 9) + 5 * 3)", 1689600), + ("7 * 8", 56), + ("3 + (5 * 3 + (5 * 9) * 2 + 4) + 2 + 3", 1448), + ("6 + 8 + 3 + (2 * (6 + 5 + 3 * 8 + 9) * 3 * 9) * (6 * 8)", 617712), + ("2 * 9 * 4 * (6 * 2 * 6 * 3 * 8) * 4", 497664), + ("6 + (3 * 4 * 7 + 5 * 5 + 2) * 4 + (6 * 5 * (6 + 2 + 9 + 6 * 8) * 2 + 5) + 4", 39189072), + ("6 * ((6 + 4) + 9 * 5 * 3 + (9 * 5)) * (4 + 2 * 7 * (4 * 9 * 3 * 8) * 4) + 3", 3971440800), + ("7 * 2 + 6 * (3 * 6 + 6 * 5) * 7 * 7", 493920), + ("3 + 8 * (3 * 2 + (9 * 3 + 8 * 7 + 8 + 4) + 6 + 3 + 5) + (6 + 8 + 7 * 3) * 9 * (4 * 3 * 6 + (9 + 9 * 9 * 2 * 6) + 4 + (6 * 4 + 5 + 9 + 9 + 7))", 14751552816), + ("4 * 8 * (8 * 5 + 3 * 6 * 7 + 9) * 9", 1769472), + ("8 + 4 * 9 * 4 * 8", 3456), + ("(3 * 7 + (5 * 2 + 7 + 5 * 6) + 9 * 5) * 6 + 6 + 2 * 5", 457800), + ("(8 + (4 * 8 * 8) * 7) + 4 * 8 * ((4 * 4 * 5) + 8 + 8 + 2) + ((6 * 8) * 8 * 8 * 8 * 2) + 8", 729806528), + ("4 * (6 + 2 + 6 + 9 + 7) * 4 + 7 + 9", 2400), + ("5 + (2 + 6 * 8 + 5) + (6 + (8 + 9 + 5) * 4 * 3) * 4 * 5", 8900), + ("9 * 6 + 5 * (4 + 2 + (7 + 9 * 6)) + 5 + 6", 11187), + ("8 + ((8 + 3 + 5 + 3 * 8) + 5 + 3) * 4 * 3", 2016), + ("2 + (3 + 5 * (8 * 2) + 8 + 5) * 8 + 4 + (8 + (9 + 8) + 8 * 9 * 7) + 9", 491400), + ("7 * (4 * 2 + 5) * 8", 1568), + ("3 + 5 + 7 + (6 + 2 * 7 * 7 * 5) + ((3 * 4 + 8 * 5 + 6) + 4 * 5)", 3975), + ("(9 + 6) * 7 * (9 + 3 + 4 * (8 + 8 * 3 + 6 + 8 * 2))", 913920), + ("2 + (6 + 5 + (7 * 5 + 5 + 9 + 7 + 6) + 2 + 2 * (8 + 8))", 3826), + ("4 * 9 + 2 * 9 + 9 + 8", 1144), + ("((2 * 7 * 5) * 8) * 8 + 4 + 8 * 4", 44800), + ("7 * 5 + (8 + 9) * 3 * 6", 2772), + ("8 + ((9 + 7 + 8) + (8 * 5) + 2 + 7 + 3 + 3) + 3", 90), + ("6 * (5 * (7 + 6 + 5 * 9 + 8 * 5) * 6) + 7 * 9 * ((2 + 5 * 8 * 2 + 3) * 3 + 7 + 5 * 3) * 2", 62470245600), + ("3 * (3 + 5 + 4) * 6 * 9", 1944), + ("6 + ((8 * 5 + 3 + 9) * (5 + 2 * 4 * 5 + 5) + (2 * 3) + 4 + 7) + 7 + 8 * 6 + 4", 404130), + ("((9 * 2 + 8 * 9) * 4 + 5 * 3 * (8 * 2 * 7)) + (7 + 4 * 2 + 6) * 9", 22045752), + ("(6 * 5 + 7 * (5 * 5 + 4 + 7 * 7 + 6) + 2) * ((4 + 6 * 5 * 6 + 7) + 9 + 5) * 7 * (4 + 7 * 6 + 5) * 5", 210970488960), + ("8 * (3 * 6 + 5) + 9 * (9 + 6 * (4 * 6) + (7 + 8 + 5 + 3)) * (3 * 7 * 8 * 2) + 9", 81723600), + ("8 * 3 + (5 + 3) + 8 * 4 + (4 + (7 + 9 * 5 * 3) * 6 + (7 + 5 + 4) + 8 * 8)", 8901728), + ("2 * 3 + ((8 * 8 * 8 + 4) * 7 * 7) * 5 * 8", 3010800), + ("(6 * (7 + 3 + 8 * 5 + 2) + 2 * 4 + 5 * 5) * 2 * (8 + 3 + 3 + (6 + 4) * (9 * 3)) + 6 * 9", 406840320), + ("8 * (7 * 6 * 8 * (3 * 6 + 4 + 6 + 2 + 2) * 6) + 8 * 8 * 6", 46451712), + ("(7 * 5 * 5) * 7 * ((3 + 6 + 3 + 4 + 2 * 2) * 8 * (7 + 9 * 9 * 9))", 457228800), + ("((5 + 7 * 9 * 2 + 7) + 7 + 5 * 6 + 3) * 6 * 2 * 3", 318816), + ("5 + (5 * (9 + 9) + (7 * 7 * 4 + 2) * 3)", 4685), + ("((8 * 8 + 2 + 8 * 9) * 5) + (2 + (9 * 6 + 9 + 7) * 7)", 7880), + ("3 + ((7 * 4 * 4 * 5) * (8 + 3 * 4 + 4 * 9) * 5 * 3 + 7) + 4 * 2 * 7 * (3 * 6 * 6)", 33530122584), + ("((9 * 7 + 6 + 7 * 9 + 2) * 4 + 3 + 4 + 4 * 6) * 8 + (4 + (8 + 2 * 6 * 4 * 3)) + (5 + 2 * 6 * (4 * 5 + 4 + 2)) + 4 * (6 + 3 * (2 * 2 * 6 * 3) + 8 + 4 * 5)", 1740572064000), + ("(5 * (7 + 9 + 5) + 6) * 5 * (6 + 7 * 9 + 6) * 9 * 5 + 9", 16584750), + ("(4 * 4 * 6 * (5 * 8 + 3 + 8) + 5) + (9 * (3 * 9 + 3 * 9) + 5 + 8 + 2 * 3) * 3 * 2 + 8 * 5", 2812950), + ("7 + 5 * (3 + 8 + 6 * 9 + 5 * 8) * ((9 * 9 * 4 * 9 + 3) * (6 + 9 * 5) * 8 + 4 + 6)", 119924582400), + ("7 + 8 * ((3 + 7 * 5) + 3 * 2 + 2 * 3 + 7) * 9 + 8 * 7", 3784200), + ("3 + 4 + (5 * (9 + 9 + 3 * 6 * 4 * 3) * 4) * (4 * (7 * 6 * 3 + 5 * 2 * 9) + (7 * 3 + 5))", 738510752), + ("3 * (2 + 8 + 2) * 6 * (4 * 4)", 3456), + ("2 + 2 + 3 * 5 + (3 + (6 + 2) + 9 + 7) * (3 * 3 + 5 + 8 + 7)", 15456), + ("4 + 5 + 6 * 6 * 6 + (3 * 2 * 3 * (2 * 6 + 9) + 6 + (5 + 2 + 9 * 6))", 214380), + ("((4 + 9) + 2) * 7 + 3 * 4", 600), + ("2 + 6 * ((2 * 7 * 8 * 3 + 8 + 4) + 9 + 6 + 9 * 2 + 9) + 7 * 6", 900048), + ("9 * 7 + ((2 + 5 * 2 * 7 * 8) + 6 * 2 + 3 + 4) * 5 * (5 + 2 * 7) * 8", 125543880), + ("4 * (8 + 5 * 6 * 8) + 2 + 3 * 7", 17612), + ("(2 * 2) * 9 * 6 * 3 + 9", 2592), + ("9 + 2 * (7 + 5 + 7 + (3 + 7 * 2 * 2 + 3) * 3)", 3927), + ("(2 + 5 * 9) * (4 * (9 + 2 * 4 + 3 + 2) * 2 + 8 + (6 * 7 + 9 + 5)) * 3 + 8", 37322208), + ("(6 * (6 + 7 * 7) + 7 * 6 * 7) + ((7 * 6 * 4) * 6 * (8 + 8 + 5 * 7 * 8 + 8) + (4 + 5 * 5 + 5 + 3 * 9) + 8)", 3465000), + ("9 * (6 * 9 * (8 * 2 * 6) + 4 * 4)", 194400), + ("(5 + 5 * 5 + 8) * 6 + 5 * 2", 2860), + ("4 + ((8 + 7) + 5) + 6", 30), + ("9 + 6 * (7 + 4 + (9 + 4 + 2 + 8)) + (8 * 5)", 1110), + ("(3 * 8 + (6 + 9 * 8 + 6)) + 3 + 4 * 8 + 5 * 3", 25779), + ("3 + 6 * (7 * 8 * 6 * (5 + 8 + 6) + 5 * 4) * ((8 + 9 + 6 * 8) * 9 + 6 * 6 + 2 * 2) * 4", 51279298560), + ("7 * (6 * (5 * 5 + 9 * 7 + 5 + 9) + 8 + 9 + 2 * (6 * 7 * 7)) * 3", 55158516), + ("4 + 2 * (5 * (3 * 8 * 3) * (5 + 9 + 8 * 9) + 9 + 7) * 7 + 5", 5546880), + ("6 * 5 * (5 * 3 * 9 * 4 * 2) * 9 + 7 * 4", 2073600), + ("3 * (4 * (7 + 2) + 4 + 6 + (3 + 6 + 6 * 5)) + 5", 1143), + ("7 * 7 * (5 + 9 + 9) * (8 * 6 * 5 + 4 * 2)", 973728), + ("6 + (9 * 4) * ((4 * 2 * 4 * 4 * 6 * 7) + 9 + (2 * 9 + 9 + 9)) + 2 + 4 + 4", 228858), + ("9 * (6 * 5 + 9 * 2 * 4) + 7 + 8 * 8 + 9", 105111), + ("(6 + 7 + 8 * 2 * 4) * 5 + 2 + 2 * 5 + 6", 16632), + ("8 * 7 * (9 * 2 * 4 + 3 + 4 * 4) + (8 * 8 + 9 + 6) + ((7 * 7 + 2 * 9) * (2 * 8 + 2) * 6 * 6) + 8", 22916544), + ]; + // Find shortest failures first, that should make it easier to understand. + ts.sort_by(|l, r| l.0.len().cmp(&r.0.len())); + for (input, want) in ts { + let got = parse(&lex(input)); + eprintln!("got {}, want {} for {}", got, want, input); + assert_eq!(got, want, "got {}, want {} for {}", got, want, input); } } }