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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


fn calc(a: i64, d: i64, e: i64) -> i64 {
    return e + d;
}
fn main() -> i64 {
    let r = calc(8, 3, 3);
    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(8, 3, 3);
    println(r);
    return 0;
}


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

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

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

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


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

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


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

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

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


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

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

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

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


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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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(1, 1);
    println(r);
    return 0;
}


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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

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

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

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


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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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


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

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

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


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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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