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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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