fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(8);
    println(r;
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64 -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn f2(x: i64) -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64 -> i64 {
    return f0 + 9;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn f2(x: i64 -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn f2(x: i64 -> i64 {
    return f1 * 3;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn f2(x: i64) -> i64 {
    return f1 * 2;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(9);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(8;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(3);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(6;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(9);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main( -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main( -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main( -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main( -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64 -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(8;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(6);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main( -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(8;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main( -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(2);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 6;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main( -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64 -> i64 {
    return f1 + 5;
}
fn main() -> i64 {
    let r = f2(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 0;
}
fn main() -> i64 {
    let r = f2(0);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 7;
}
fn main() -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64 -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 2;
}
fn main() -> i64 {
    let r = f2(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(0);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 8;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 3;
}
fn main() -> i64 {
    let r = f2(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(7);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main() -> i64 {
    let r = f2(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64 -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main() -> i64 {
    let r = f2(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 4;
}
fn main() -> i64 {
    let r = f2(9;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 * 3;
}
fn f2(x: i64) -> i64 {
    return f1 + 9;
}
fn main( -> i64 {
    let r = f2(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 * 2;
}
fn f2(x: i64) -> i64 {
    return f1 + 1;
}
fn main( -> i64 {
    let r = f2(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main( -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(9;
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64 -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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

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


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


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

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


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(4);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main( -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main( -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main( -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(1);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main( -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64 -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main( -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(3;
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(3);
    println(r;
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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


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

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


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


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


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

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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64 -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64 -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r;
    return 0;
}


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


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


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64 -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main( -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64 -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64 -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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

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


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

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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

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


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

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 1;
}


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


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main( -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(7;
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(7;
    println(r);
    return 0;
}


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


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

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main( -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(2;
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(5;
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(8);
    println(r;
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(1;
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(5);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}

fn f0(x: i64 -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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


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

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


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


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


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

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


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


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


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main( -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


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

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 9;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 1;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(2);
    println(r);
    return 0;
}


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

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


fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 1;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 0;
}
fn main() -> i64 {
    let r = f1(0);
    println(r);
    return 0;
}

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


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

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


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


fn f0(x: i64) -> i64 {
    return x + 3;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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


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

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


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 0;
}
fn f1(x: i64) -> i64 {
    return f0 + 5;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 4;
}
fn f1(x: i64) -> i64 {
    return f0 + 4;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(3);
    println(r);
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 7;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 8;
}
fn main() -> i64 {
    let r = f1(7);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 1;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 6;
}
fn f1(x: i64) -> i64 {
    return f0 + 2;
}
fn main() -> i64 {
    let r = f1(1;
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 2;
}
fn f1(x: i64) -> i64 {
    return f0 + 6;
}
fn main() -> i64 {
    let r = f1(8);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 9;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(9);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r);
    return 0;
}

fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(4);
    println(r;
    return 0;
}


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 3;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


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

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


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


fn f0(x: i64) -> i64 {
    return x + 5;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(6);
    println(r);
    return 0;
}


fn f0(x: i64) -> i64 {
    return x + 8;
}
fn f1(x: i64) -> i64 {
    return f0 + 7;
}
fn main() -> i64 {
    let r = f1(1);
    println(r);
    return 0;
}