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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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