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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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

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


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

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

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

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