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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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


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

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

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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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

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


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

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


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

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


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

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

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


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


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

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

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


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

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


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

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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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