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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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