fn calc(b: i64) -> i64 {
    return 4 + b;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 4 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 2 + b;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 2 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return 2 - b;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 7 + b;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 7 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return 7 + b;
}
fn main() -> i64 {
    let r = calc(3);
    println(r;
    return 0;
}


fn calc(b: i64) -> i64 {
    return 3 + b;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 3 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return 3 - b;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 8 + b;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 8 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 4 + b;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 4 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return 5 + b;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 9 + b;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 9 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    return 9 + b;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 7 + b;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 7 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return 7 + b;
}
fn main() -> i64 {
    let r = calc(8;
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return 2 + b;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = 2 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    return 2 + b;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 0, 3);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(6, 0, 3);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 0, 3;
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 2, 5);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(1, 2, 5);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = c - c;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 2, 5);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    return 3 - b;
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let c = 3 - b;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    return 3 - b;
}
fn main( -> i64 {
    let r = calc(8, 6);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((b - b - b + b) * (b - 8));
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b - b - b + b);
    t = t * (b - 8);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b - b - b + b) * (b - 8));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    return (d + d + d - 8);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d + d + d - 8);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t + d + d - 8;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d + d + d - 8;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    return (d + d + d - 3);
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t + d + d - 3;
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d + d + d - 3);
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d + d + d - 2);
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let t = d;
    t = t * 0 * d + d;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d * 0 * d + d);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d * 0 * d + d);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t * 0 * d + d;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r;
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 11);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return a + a;
}
fn main() -> i64 {
    let r = calc(4, 11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return a + a;
}
fn main() -> i64 {
    let r = calc(1, 10);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return a + a;
}
fn main() -> i64 {
    let r = calc(11, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = a - a;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 7);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return a + a;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64 -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return a + a;
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}

fn calc(b: i64, a: i64) -> i64 {
    let c = a + a;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 5);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = (b * 7 + b);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 9, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    return (b * 7 + b);
}
fn main() -> i64 {
    let r = calc(9, 9, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let t = b;
    t = t * 7 + b;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 9, 9);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    let t = 8;
    t = t * 2 + c + c;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (8 * 2 + c + c);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (8 * 2 + c + c);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return d * a;
}
fn main() -> i64 {
    let r = calc(11, 5, 11);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = d * a;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 5, 11);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = b * b;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return b * b;
}
fn main() -> i64 {
    let r = calc(0, 4, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t + c + 6;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (c + c + 6);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (c + c + 6);
}
fn main() -> i64 {
    let r = calc(2, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = c;
    t = t + c + 6;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 4);
    println(r;
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = d * 8;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return d * 8;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = d + 8;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = ((4 + 9 * 5 + b) + (8 + b + 4 - b));
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (4 + 9 * 5 + b);
    t = t + (8 + b + 4 - b);
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((4 + 9 * 5 + b) + (8 + b + 4 + b));
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = 8 * 5;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 12, 4);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    return 8 * 5;
}
fn main() -> i64 {
    let r = calc(5, 12, 4);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = 7 * 4;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 7, 4);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    return 7 * 4;
}
fn main() -> i64 {
    let r = calc(9, 7, 4);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = 7;
    t = t * (b + b + b);
    return t;
}
fn main() -> i64 {
    let r = calc(7, 8, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return (7 * (b + b + b));
}
fn main() -> i64 {
    let r = calc(7, 8, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = (7 * (b + b + b));
    return c;
}
fn main() -> i64 {
    let r = calc(7, 8, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = 7;
    t = t * (b + b + b);
    return t;
}
fn main() -> i64 {
    let r = calc(7, 8, 0;
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let t = (8 - 1);
    t = t * (1 + 5 * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 0);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return c - e;
}
fn main() -> i64 {
    let r = calc(10, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = c - e;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return c - e;
}
fn main() -> i64 {
    let r = calc(10, 9);
    println(r);
    return 1;
}


fn calc(a: i64) -> i64 {
    return (a + 7 * 0);
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = a;
    t = t + 7 * 0;
    return t;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a + 7 * 0);
    return c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64 -> i64 {
    return (a + 7 * 0);
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = e - d;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 1, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return e - d;
}
fn main() -> i64 {
    let r = calc(3, 1, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = e + d;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 1, 8);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    return c * 7;
}
fn main() -> i64 {
    let r = calc(9, 4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = c * 7;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 4, 4);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    return c * 9;
}
fn main() -> i64 {
    let r = calc(10, 12, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = c * 9;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 12, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    return c + 9;
}
fn main() -> i64 {
    let r = calc(10, 12, 6);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let c = (d * d + 3 + 4);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = d;
    t = t * d + 3 + 4;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (d * d + 3 + 4);
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = (d * d + 3 + 4;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}


fn calc(a: i64, e: i64) -> i64 {
    let c = (e + 8 + 8);
    return c;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    return (e + 8 + 8);
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let t = e;
    t = t + 8 + 8;
    return t;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 0;
}

fn calc(a: i64, e: i64) -> i64 {
    let c = (e + 8 + 8);
    return c;
}
fn main() -> i64 {
    let r = calc(1, 5);
    println(r);
    return 1;
}


fn calc(a: i64) -> i64 {
    return ((a * a + a) + a);
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = (a * a + a);
    t = t + a;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = ((a * a + a) + a);
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return ((a * a - a) + a);
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    let c = (a * b + b);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = a;
    t = t * b + b;
    return t;
}
fn main() -> i64 {
    let r = calc(5, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    return (a * b + b);
}
fn main() -> i64 {
    let r = calc(5, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = (a * b + b);
    return c;
}
fn main() -> i64 {
    let r = calc(5, 1);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = ((e + e - d) * (d * e * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 9, 9);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let t = (e + e - d);
    t = t * (d * e * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(8, 9, 9);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64, e: i64) -> i64 {
    let c = ((e + e - d) * (d * e * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 9, 9);
    println(r;
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = c * 3;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return c * 3;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    let c = c * 3;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let t = (d - d - 6 * d);
    t = t * (a + d + d * 9);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 12);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = ((d - d - 6 * d) * (a + d + d * 9));
    return c;
}
fn main() -> i64 {
    let r = calc(9, 12);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return ((d - d - 6 * d) * (a + d + d * 9));
}
fn main() -> i64 {
    let r = calc(9, 12);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = (d - d - 6 * d);
    t = t * (a + d + d * 9);
    return t;
}
fn main() -> i64 {
    let r = calc(9, 12);
    println(r;
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (e + 1 * e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e + 1 * e * e);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t + 1 * e * e;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + 1 * e * e);
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = (c - 6);
    t = t - (4 - e * c + b);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = ((c - 6) - (4 - e * c + b));
    return c;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = (c - 6;
    t = t - (4 - e * c + b);
    return t;
}
fn main() -> i64 {
    let r = calc(5, 2, 3);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = (b - a);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    return (b - a);
}
fn main() -> i64 {
    let r = calc(0, 4, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let t = b;
    t = t - a;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 4, 5);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64, a: i64) -> i64 {
    let c = (b - a);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4, 5);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (8 * 7 * e - 0);
    t = t - (e * e + 7);
    return t;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = (e + d);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (e + d);
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = e;
    t = t + d;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = (e - d);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = (d - b * 9 + b);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 0, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    return (d - b * 9 + b);
}
fn main() -> i64 {
    let r = calc(0, 0, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let t = d;
    t = t - b * 9 + b;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 0, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = (d - b + 9 + b);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 0, 12);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * 1 * 0);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * 1 * 0;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * 1 * 0);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64 -> i64 {
    return (c * 1 * 0);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * 5 * 6);
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * 5 * 6;
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * 5 * 6);
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * 5 * 6);
}
fn main() -> i64 {
    let r = calc(12);
    println(r;
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * 2 * 0);
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * 2 * 0);
    return c;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * 2 * 0;
    return t;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    return (c * 2 * 0);
}
fn main() -> i64 {
    let r = calc(4;
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = (b * b - b);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b * b - b);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t * b - b;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = (b * b - b);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r;
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = b + 7;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 5, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return b + 7;
}
fn main() -> i64 {
    let r = calc(9, 5, 5);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return (9 * a);
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = 9;
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (9 * a);
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (9 + a);
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = ((a + 4 - a + a) + (9 + c * a - d));
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let t = (a + 4 - a + a);
    t = t + (9 + c * a - d);
    return t;
}
fn main() -> i64 {
    let r = calc(4, 5, 7);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return ((3 * a * 9) * (0 * a + a));
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = (3 * a * 9);
    t = t * (0 * a + a);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = ((3 * a * 9) * (0 * a + a));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return ((3 * a * 9) * (0 * a + a));
}
fn main( -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(2, 3);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 4;
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(5, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 6);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(5, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r;
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(2, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 12);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(2, 12);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(9, 1);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 1);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 11);
    println(r;
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(1, 9;
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main( -> i64 {
    let r = calc(8, 10);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(5, 5);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(4, 1);
    println(r);
    return 1;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64 -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(1, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main( -> i64 {
    let r = calc(1, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(9, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 7);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(9, 7);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(1, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = b;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 12);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return b;
}
fn main() -> i64 {
    let r = calc(1, 12);
    println(r);
    return 1;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return 9 + c;
}
fn main() -> i64 {
    let r = calc(10, 11, 1);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = 9 + c;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 11, 1);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    let t = (b + b + b);
    t = t * (4 + b + 6);
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((b + b + b) * (4 + b + 6));
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((b + b + b) * (4 + b + 6));
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (b + b + b);
    t = t * (4 + b + 6;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let t = d;
    t = t - (3 - d - d);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d - (3 - d - d));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d - (3 - d - d));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t - (2 - d - d);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(1, 6, 2);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 6, 2);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(1, 6, 2;
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(3, 9, 11);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 9, 11);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(3, 9, 10);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(1, 12, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 12, 6);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64, c: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(1, 12, 6);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(9, 8, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 8, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main( -> i64 {
    let r = calc(9, 8, 0);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(9, 5, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 5, 0);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(9, 5, 0);
    println(r);
    return 1;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(12, 4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(12, 4, 5);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(4, 12, 9);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 12, 9);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64, b: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(4, 12, 9);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(5, 9, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 9, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(5, 9, 6);
    println(r;
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(1, 1, 5);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 1, 5);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(0, 8, 2);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 8, 2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(10, 6, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 6, 8);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64, b: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(10, 6, 8);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return e;
}
fn main() -> i64 {
    let r = calc(4, 0, 11);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = e;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 0, 11);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (e * e + e);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t * e + e;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e * e + e);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + e + e);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, d: i64) -> i64 {
    let c = (b - 5);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 0, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    let t = b;
    t = t - 5;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 0, 3);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, d: i64) -> i64 {
    return (b - 5);
}
fn main() -> i64 {
    let r = calc(0, 0, 3);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    let c = ((b + c * c + 7) - (2 * 7));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (b + c * c + 7);
    t = t - (2 * 7);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = ((b + c * c + 7) - (2 * 7);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = (8 + (8 * e - e * 9));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 8;
    t = t + (8 * e - e * 9);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (8 + (8 * e - e * 9));
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (8 + (8 * e - e * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = ((3 - d + e - 8) * c);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 5, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = (3 - d + e - 8);
    t = t * c;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 5, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = ((3 - d + e - 8) * c);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 5, 8);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    return (9 * b * a);
}
fn main() -> i64 {
    let r = calc(11, 12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let t = 9;
    t = t * b * a;
    return t;
}
fn main() -> i64 {
    let r = calc(11, 12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = (9 * b * a);
    return c;
}
fn main() -> i64 {
    let r = calc(11, 12, 0);
    println(r);
    return 0;
}

fn calc(d: i64, b: i64, a: i64) -> i64 {
    return (9 * b * a);
}
fn main() -> i64 {
    let r = calc(11, 12, 0);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = b * d;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 4, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    return b * d;
}
fn main() -> i64 {
    let r = calc(2, 4, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = b * d;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 5, 9);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64) -> i64 {
    let c = (b + d + d);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    let t = b;
    t = t + d + d;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64) -> i64 {
    return (b + d + d);
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}

fn calc(d: i64, b: i64) -> i64 {
    let c = (b + d + d);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 7);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return ((a * a + 4) + (5 + a));
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = ((a * a + 4) + (5 + a));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = (a * a + 4);
    t = t + (5 + a);
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return ((a * a + 4) + (5 + a));
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    return (8 * 5);
}
fn main() -> i64 {
    let r = calc(2, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = 8;
    t = t * 5;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 7);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (8 * 5);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 7);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return (e * 8 * c);
}
fn main() -> i64 {
    let r = calc(0, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (e * 8 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(0, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = e;
    t = t * 8 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(0, 9);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return (e * 8 * c;
}
fn main() -> i64 {
    let r = calc(0, 9);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return (e * 6 * c);
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = e;
    t = t * 6 * c;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = (e * 6 * c);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(10, 3);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(10, 3);
    println(r);
    return 0;
}

fn calc(e: i64, c: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(10, 3);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(9, 11);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 11);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return c - c;
}
fn main() -> i64 {
    let r = calc(9, 11);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(11, 6);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = c + c;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 6);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64 -> i64 {
    return c + c;
}
fn main() -> i64 {
    let r = calc(11, 6);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    let c = (7 * 7 * b * e);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return (7 * 7 * b * e);
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let t = 7;
    t = t * 7 * b * e;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = (7 * 7 * b * e);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r;
    return 0;
}


fn calc(d: i64) -> i64 {
    let t = d;
    t = t - d - d + 3;
    return t;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d - d - d + 3);
    return c;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d - d - d + 3);
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}

fn calc(d: i64 -> i64 {
    let t = d;
    t = t - d - d + 3;
    return t;
}
fn main() -> i64 {
    let r = calc(4);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let c = (c - c + c);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = c;
    t = t - c + c;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (c - c + c);
}
fn main() -> i64 {
    let r = calc(2, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (c - c + c);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let t = b;
    t = t + 3 * b + a;
    return t;
}
fn main() -> i64 {
    let r = calc(1, 2, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return (b + 3 * b + a);
}
fn main() -> i64 {
    let r = calc(1, 2, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = (b + 3 * b + a);
    return c;
}
fn main() -> i64 {
    let r = calc(1, 2, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64 -> i64 {
    let t = b;
    t = t + 3 * b + a;
    return t;
}
fn main() -> i64 {
    let r = calc(1, 2, 9);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let c = ((1 * 4 + 9) - (6 + 1 + e * e));
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = (1 * 4 + 9);
    t = t - (6 + 1 + e * e);
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = ((1 * 4 + 9) - (6 + 1 + e * e));
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return (1 + (a + a * a * a));
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (1 + (a + a * a * a));
    return c;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = 1;
    t = t + (a + a * a * a);
    return t;
}
fn main() -> i64 {
    let r = calc(0);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (1 + (a + a * a * a));
}
fn main() -> i64 {
    let r = calc(0;
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (7 * 3 + d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 11, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = 7;
    t = t * 3 + d;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 11, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (7 * 3 + d);
}
fn main() -> i64 {
    let r = calc(9, 11, 8);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64, e: i64) -> i64 {
    let c = (7 * 3 + d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 11, 8);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (c - 5 + c);
    t = t + (1 * e + 3);
    return t;
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((c - 5 + c) + (1 * e + 3));
    return c;
}
fn main() -> i64 {
    let r = calc(11, 4);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    return (c + a + c);
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (c + a + c);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = c;
    t = t + a + c;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (c - a + c);
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let t = (5 - d);
    t = t + (d + 3 - 4 + d);
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return ((5 - d) + (d + 3 - 4 + d));
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((5 - d) + (d + 3 - 4 + d));
    return c;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (4 - d);
    t = t + (d + 3 - 4 + d);
    return t;
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (e + (1 + e * c + d));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 4, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return (e + (1 + e * c + d));
}
fn main() -> i64 {
    let r = calc(8, 4, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = e;
    t = t + (1 + e * c + d);
    return t;
}
fn main() -> i64 {
    let r = calc(8, 4, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = (e - (1 + e * c + d));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 4, 12);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    return (9 * d * e + 1);
}
fn main() -> i64 {
    let r = calc(3, 4);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = (9 * d * e + 1);
    return c;
}
fn main() -> i64 {
    let r = calc(3, 4);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = 9;
    t = t * d * e + 1;
    return t;
}
fn main() -> i64 {
    let r = calc(3, 4);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (9 * d * e + 1);
}
fn main( -> i64 {
    let r = calc(3, 4);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let t = a;
    t = t - 1 - 4 * a;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a - 1 - 4 * a);
    return c;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (a - 1 - 4 * a);
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}

fn calc(a: i64 -> i64 {
    let t = a;
    t = t - 1 - 4 * a;
    return t;
}
fn main() -> i64 {
    let r = calc(5);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = 6 * b;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 6, 4);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    return 6 * b;
}
fn main() -> i64 {
    let r = calc(2, 6, 4);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = 6 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 6, 4);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = 7 * b;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 2, 4);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    return 7 * b;
}
fn main() -> i64 {
    let r = calc(5, 2, 4);
    println(r);
    return 0;
}


fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = 8 * b;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 8, 3);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    return 8 * b;
}
fn main() -> i64 {
    let r = calc(3, 8, 3);
    println(r);
    return 0;
}

fn calc(b: i64, d: i64, e: i64) -> i64 {
    let c = 8 + b;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 8, 3);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 8 * a;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 8 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 8 + a;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 2 * a;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 2 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 3 * a;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 3 * a;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 3 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 3 * a;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 2 * a;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 2 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64 -> i64 {
    return 2 * a;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 4 * a;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 4 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 5 * a;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 5 * a;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 5 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(9);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 8 * a;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 8 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 7 * a;
}
fn main() -> i64 {
    let r = calc(1);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    return 9 * a;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = 9 * a;
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return 9 * a;
}
fn main( -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return (9 * 1 + d);
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = (9 * 1 + d);
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = 9;
    t = t * 1 + d;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64) -> i64 {
    return (9 * 1 + d);
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64) -> i64 {
    return ((a * a * b) * (a + b * 5));
}
fn main() -> i64 {
    let r = calc(10, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let t = (a * a * b);
    t = t * (a + b * 5);
    return t;
}
fn main() -> i64 {
    let r = calc(10, 7);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64) -> i64 {
    let c = ((a * a * b) * (a + b * 5));
    return c;
}
fn main() -> i64 {
    let r = calc(10, 7);
    println(r);
    return 0;
}

fn calc(b: i64, a: i64) -> i64 {
    return ((a * a * b) * (a + b * 5));
}
fn main() -> i64 {
    let r = calc(10, 7);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    return 5 - e;
}
fn main() -> i64 {
    let r = calc(3, 5);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = 5 - e;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 5);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return 5 + e;
}
fn main() -> i64 {
    let r = calc(3, 5);
    println(r);
    return 0;
}


fn calc(b: i64, e: i64) -> i64 {
    return 9 - e;
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    let c = 9 - e;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}

fn calc(b: i64, e: i64) -> i64 {
    return 9 + e;
}
fn main() -> i64 {
    let r = calc(9, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    return (d - d - d);
}
fn main() -> i64 {
    let r = calc(9, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let t = d;
    t = t - d - d;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = (d - d - d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return (d - d - d);
}
fn main() -> i64 {
    let r = calc(10, 9);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, d: i64) -> i64 {
    return (9 + c);
}
fn main() -> i64 {
    let r = calc(9, 12, 9);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let t = 9;
    t = t + c;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 12, 9);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    let c = (9 + c);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 12, 9);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, d: i64) -> i64 {
    return (9 + c);
}
fn main() -> i64 {
    let r = calc(9, 12, 9);
    println(r;
    return 0;
}


fn calc(b: i64) -> i64 {
    let c = (b * 2);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return (b * 2);
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = b;
    t = t * 2;
    return t;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}

fn calc(b: i64 -> i64 {
    let c = (b * 2);
    return c;
}
fn main() -> i64 {
    let r = calc(8);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    let t = 3;
    t = t - (1 + 5);
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (3 - (1 + 5));
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (3 - (1 + 5));
    return c;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = 3;
    t = t - (2 + 5);
    return t;
}
fn main() -> i64 {
    let r = calc(3);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = ((a + a * b + b) * d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 9, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    return ((a + a * b + b) * d);
}
fn main() -> i64 {
    let r = calc(9, 9, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let t = (a + a * b + b);
    t = t * d;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 9, 1);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = ((a + a + b + b) * d);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 9, 1);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    return ((a * c - a) + (c + 1 - 4 * c));
}
fn main() -> i64 {
    let r = calc(8, 4);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = (a * c - a);
    t = t + (c + 1 - 4 * c);
    return t;
}
fn main() -> i64 {
    let r = calc(8, 4);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((a * c - a) + (c + 1 - 4 * c));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 4);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return ((a * c - a) + (c + 1 - 4 * c);
}
fn main() -> i64 {
    let r = calc(8, 4);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let t = (d - d * e);
    t = t * (1 * d + e - d);
    return t;
}
fn main() -> i64 {
    let r = calc(1, 10, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = ((d - d * e) * (1 * d + e - d));
    return c;
}
fn main() -> i64 {
    let r = calc(1, 10, 2);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return (9 - 5 * c * e);
}
fn main() -> i64 {
    let r = calc(9, 4, 10);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let t = 9;
    t = t - 5 * c * e;
    return t;
}
fn main() -> i64 {
    let r = calc(9, 4, 10);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    let c = (9 - 5 * c * e);
    return c;
}
fn main() -> i64 {
    let r = calc(9, 4, 10);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64, e: i64) -> i64 {
    return (9 - 5 * c * e);
}
fn main() -> i64 {
    let r = calc(9, 4, 10);
    println(r;
    return 0;
}


fn calc(d: i64) -> i64 {
    return ((d * d + d) + (d + 5 - 1));
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((d * d + d) + (d + 5 - 1));
    return c;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (d * d + d);
    t = t + (d + 5 - 1);
    return t;
}
fn main() -> i64 {
    let r = calc(6);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return 8 + 7;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 8 + 7;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 8 - 7;
}
fn main() -> i64 {
    let r = calc(4, 5);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = e + d;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 10, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    return e + d;
}
fn main() -> i64 {
    let r = calc(11, 10, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64, e: i64) -> i64 {
    let c = e - d;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 10, 1);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    return ((3 * d + 2 * 9) * d);
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((3 * d + 2 * 9) * d);
    return c;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (3 * d + 2 * 9);
    t = t * d;
    return t;
}
fn main() -> i64 {
    let r = calc(2);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return ((3 * d + 2 * 9) * d);
}
fn main() -> i64 {
    let r = calc(2;
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    let t = b;
    t = t * e + a;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 1, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = (b * e + a);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 1, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    return (b * e + a);
}
fn main() -> i64 {
    let r = calc(4, 1, 9);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64 -> i64 {
    let t = b;
    t = t * e + a;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 1, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return ((d + c + d - 3) * 4);
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = (d + c + d - 3);
    t = t * 4;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = ((d + c + d - 3) * 4);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return ((d + c + d - 3) * 4);
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 1;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    let t = (b * a - e * e);
    t = t + e;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 0, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    return ((b * a - e * e) + e);
}
fn main() -> i64 {
    let r = calc(2, 0, 5);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = ((b * a - e * e) + e);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 0, 5);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    return d + d;
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = d + d;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 3);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    return d + d;
}
fn main() -> i64 {
    let r = calc(11, 5);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = d + d;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 5);
    println(r);
    return 0;
}

fn calc(d: i64, a: i64) -> i64 {
    return d + d;
}
fn main() -> i64 {
    let r = calc(11, 5);
    println(r);
    return 0;
}


fn calc(e: i64) -> i64 {
    return (e + e * 6 + e);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let t = e;
    t = t + e * 6 + e;
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    let c = (e + e * 6 + e);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(e: i64) -> i64 {
    return (e + e * 6 + e);
}
fn main() -> i64 {
    let r = calc(11);
    println(r;
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = ((3 * c * d + 2) + (c + d - d + c));
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = (3 * c * d + 2);
    t = t + (c + d - d + c);
    return t;
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return ((3 * c * d + 2) + (c + d - d + c));
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = ((3 * c * d + 2) + (c + d - d + c));
    return c;
}
fn main() -> i64 {
    let r = calc(0, 4);
    println(r;
    return 0;
}


fn calc(c: i64) -> i64 {
    return (c * c * c);
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let t = c;
    t = t * c * c;
    return t;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}

fn calc(c: i64) -> i64 {
    let c = (c * c * c);
    return c;
}
fn main() -> i64 {
    let r = calc(7);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let t = (c + a);
    t = t - a;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = ((c + a) - a);
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return ((c + a) - a);
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(c: i64, a: i64) -> i64 {
    let t = (c + a);
    t = t - a;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return (c * c * b + c);
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = c;
    t = t * c * b + c;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = (c * c * b + c);
    return c;
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    return (c * c * b - c);
}
fn main() -> i64 {
    let r = calc(12, 4);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 1;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9;
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 2);
    println(r);
    return 1;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(2, 2);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 2;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 3);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 2;
}
fn main() -> i64 {
    let r = calc(8, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(8, 0);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 3);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(7, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(7, 9);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 3);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(7, 3);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 8;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 1;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 10);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(0, 10);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 4);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(7, 4);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 5;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 5;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 8);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 7);
    println(r;
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 8;
}
fn main() -> i64 {
    let r = calc(7, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 0);
    println(r;
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(11, 0);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 1;
}
fn main() -> i64 {
    let r = calc(11, 0);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 3);
    println(r;
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 2;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 2;
}
fn main() -> i64 {
    let r = calc(6, 2);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 1;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 2;
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(5, 8);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 10);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(9, 10);
    println(r);
    return 0;
}


fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}

fn calc(d: i64, e: i64) -> i64 {
    let c = 9;
    return c;
}
fn main( -> i64 {
    let r = calc(8, 5);
    println(r);
    return 0;
}


fn calc(a: i64) -> i64 {
    let t = a;
    t = t + (a + 8 + 3 * 6);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let c = (a + (a + 8 + 3 * 6));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    return (a + (a + 8 + 3 * 6));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(a: i64) -> i64 {
    let t = a;
    t = t + (a + 8 + 3 + 6);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, e: i64) -> i64 {
    let t = 7;
    t = t * (e * b + 7);
    return t;
}
fn main() -> i64 {
    let r = calc(8, 10, 2);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, e: i64) -> i64 {
    let c = (7 * (e * b + 7));
    return c;
}
fn main() -> i64 {
    let r = calc(8, 10, 2);
    println(r);
    return 0;
}

fn calc(e: i64, b: i64, a: i64) -> i64 {
    let t = 7;
    t = t * (e * b + 7);
    return t;
}
fn main() -> i64 {
    let r = calc(8, 10, 2);
    println(r);
    return 0;
}


fn calc(b: i64) -> i64 {
    return ((6 * b) + (b * b - b));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let t = (6 * b);
    t = t + (b * b - b);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = ((6 * b) + (b * b - b));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    return ((6 * b) + (b * b - b));
}
fn main() -> i64 {
    let r = calc(12);
    println(r);
    return 0;
}


fn calc(a: i64, d: i64) -> i64 {
    let t = 8;
    t = t * a * d + d;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let c = (8 * a * d + d);
    return c;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    return (8 * a * d + d);
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}

fn calc(a: i64, d: i64) -> i64 {
    let t = 8;
    t = t + a * d + d;
    return t;
}
fn main() -> i64 {
    let r = calc(12, 0);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return 4 * c;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = 4 * c;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return 4 * c;
}
fn main() -> i64 {
    let r = calc(4, 7);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 4 - 4;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 8, 4);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return 4 - 4;
}
fn main() -> i64 {
    let r = calc(7, 8, 4);
    println(r);
    return 0;
}


fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 9 - 5;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    return 9 - 5;
}
fn main() -> i64 {
    let r = calc(0, 12, 3);
    println(r);
    return 0;
}

fn calc(a: i64, b: i64, c: i64) -> i64 {
    let c = 9 - 6;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12, 3);
    println(r);
    return 0;
}


fn calc(c: i64, e: i64) -> i64 {
    let t = (5 * c * c + 6);
    t = t + e;
    return t;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    return ((5 * c * c + 6) + e);
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let c = ((5 * c * c + 6) + e);
    return c;
}
fn main() -> i64 {
    let r = calc(7, 12);
    println(r);
    return 0;
}

fn calc(c: i64, e: i64) -> i64 {
    let t = (5 * c * c + 6);
    t = t + e;
    return t;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return c * a;
}
fn main() -> i64 {
    let r = calc(1, 12, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = c * a;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 12, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    return c * a;
}
fn main() -> i64 {
    let r = calc(1, 13, 11);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64, e: i64) -> i64 {
    return c * a;
}
fn main() -> i64 {
    let r = calc(4, 5, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    let c = c * a;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 5, 11);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64, e: i64) -> i64 {
    return c * a;
}
fn main( -> i64 {
    let r = calc(4, 5, 11);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    return ((d + d + d) + (8 - d * d + d));
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = ((d + d + d) + (8 - d * d + d));
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = (d + d + d);
    t = t + (8 - d * d + d);
    return t;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return ((d + d + d) + (8 - d * d + d);
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 9;
    return c;
}
fn main( -> i64 {
    let r = calc(8, 11);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 7);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(0, 7);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(0, 12);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(6, 6);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 8;
}
fn main() -> i64 {
    let r = calc(8, 2);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(4, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(4, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(3, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main( -> i64 {
    let r = calc(3, 10);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 6);
    println(r);
    return 1;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(7, 5);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(6, 10);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 10);
    println(r;
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(0, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(0, 2);
    println(r);
    return 1;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 8;
}
fn main() -> i64 {
    let r = calc(9, 0);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(6, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main( -> i64 {
    let r = calc(6, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 8;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64 -> i64 {
    let c = 8;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 12);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 4;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 8);
    println(r);
    return 1;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(3, 0);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(3, 0);
    println(r);
    return 1;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 11);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 6;
}
fn main() -> i64 {
    let r = calc(5, 11);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64 -> i64 {
    let c = 6;
    return c;
}
fn main() -> i64 {
    let r = calc(5, 11);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(6, 8);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(2, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(9, 8);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 3;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 3;
}
fn main() -> i64 {
    let r = calc(1, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 4;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 2);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 1;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 1;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = 2;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 8);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 0;
    return c;
}
fn main() -> i64 {
    let r = calc(9, 6);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 0;
}
fn main() -> i64 {
    let r = calc(9, 6);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 9;
    return c;
}
fn main() -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 9;
}
fn main() -> i64 {
    let r = calc(8, 9);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(1, 12);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(1, 12);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = 7;
    return c;
}
fn main() -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return 7;
}
fn main() -> i64 {
    let r = calc(12, 1);
    println(r);
    return 0;
}


fn calc(d: i64) -> i64 {
    let c = (d + 7 - d);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    return (d + 7 - d);
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let t = d;
    t = t + 7 - d;
    return t;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}

fn calc(d: i64) -> i64 {
    let c = (d + 6 - d);
    return c;
}
fn main() -> i64 {
    let r = calc(10);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let t = a;
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (a * a);
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let c = (a * a);
    return c;
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(c: i64, a: i64) -> i64 {
    let t = a;
    t = t * a;
    return t;
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}


fn calc(a: i64, c: i64) -> i64 {
    let c = (c + 8 - c * a);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    return (c + 8 - c * a);
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64) -> i64 {
    let t = c;
    t = t + 8 - c * a;
    return t;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}

fn calc(a: i64, c: i64 -> i64 {
    let c = (c + 8 - c * a);
    return c;
}
fn main() -> i64 {
    let r = calc(10, 10);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    return ((8 * d + d * d) + (c + d + d * 8));
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = (8 * d + d * d);
    t = t + (c + d + d * 8);
    return t;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let c = ((8 * d + d * d) + (c + d + d * 8));
    return c;
}
fn main() -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return ((8 * d + d * d) + (c + d + d * 8));
}
fn main( -> i64 {
    let r = calc(7, 2);
    println(r);
    return 0;
}


fn calc(c: i64, d: i64) -> i64 {
    let c = (0 - d - d);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    let t = 0;
    t = t - d - d;
    return t;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(c: i64, d: i64) -> i64 {
    return (0 - d - d);
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}

fn calc(d: i64, c: i64) -> i64 {
    let c = (0 - d - d);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 8);
    println(r);
    return 0;
}


fn calc(b: i64, c: i64) -> i64 {
    return ((8 - c) + (8 + c + b * b));
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let t = (8 - c);
    t = t + (8 + c + b * b);
    return t;
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(b: i64, c: i64) -> i64 {
    let c = ((8 - c) + (8 + c + b * b));
    return c;
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}

fn calc(c: i64, b: i64) -> i64 {
    return ((8 - c) + (8 + c + b * b));
}
fn main() -> i64 {
    let r = calc(2, 6);
    println(r);
    return 0;
}