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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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