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

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


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

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

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


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

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

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


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

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


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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


fn calc(b: i64, c: i64) -> i64 {
    let c = (3 - c);
    return c;
}
fn main() -> i64 {
    let r = calc(4, 2);
    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(4, 2);
    println(r);
    return 0;
}

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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