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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


fn calc(b: i64, c: i64, e: i64) -> i64 {
    return b + b;
}
fn main() -> i64 {
    let r = calc(10, 7, 5);
    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(10, 7, 5);
    println(r);
    return 0;
}

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


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

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

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


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


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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

fn calc(b: i64) -> i64 {
    let t = 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 = (b * b * b - b);
    return c;
}
fn main() -> i64 {
    let r = calc(11);
    println(r);
    return 0;
}

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


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

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


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

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

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


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

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

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

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