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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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

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


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

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

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

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


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

fn calc(a: i64, b: i64, d: i64) -> i64 {
    let c = 9;
    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 9;
}
fn main( -> i64 {
    let r = calc(10, 6, 9);
    println(r);
    return 0;
}


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

fn calc(b: i64) -> i64 {
    return b + 8;
}
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(5);
    println(r);
    return 0;
}

fn calc(b: i64) -> i64 {
    let c = b + 9;
    return c;
}
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(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 {
    let c = b + 4;
    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(a: i64, b: i64, c: i64) -> i64 {
    let t = 8;
    t = t * (2 * 1 * b);
    return t;
}
fn main() -> i64 {
    let r = calc(12, 8, 12);
    println(r);
    return 0;
}

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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


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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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