fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 6);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i - 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64 -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main( -> i64 {
    let r = run(4, 5);
    println(r);
    return 0;
}


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

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


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 7);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 3);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 0;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 3);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 8);
    println(r);
    return 0;
}

fn run(a: i64, b: i64 -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 9;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main( -> i64 {
    let r = run(6, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 2);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i - 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main( -> i64 {
    let r = run(2, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 3);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p + i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 3);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 3);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i - 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 3);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p + i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 4);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p + i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 4);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 11);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p + i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 2;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 7);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 8);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 5);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 5;
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 4);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 4);
    println(r);
    return 0;
}


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


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 11);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 11);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 8);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 8);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 3);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2, 3);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main( -> i64 {
    let r = run(4, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 7);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 2);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main( -> i64 {
    let r = run(0, 2);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 7);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i - 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 7);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 9);
    println(r);
    return 0;
}

fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i - 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4, 9);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 6);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3, 6);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 2);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 2);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 5);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1, 5);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0, 1);
    println(r);
    return 0;
}


fn run(a: i64, b: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 10);
    println(r);
    return 0;
}

fn run(b: i64, a: i64) -> i64 {
    let p = 1;
    let i = a;
    while i <= b {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5, 10);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n + 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) - deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(15);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(15);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(14);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64 -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 0) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main( -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1 + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) - deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(12);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(12);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1 + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2;
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 2) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2;
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1) + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = run(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return deep(n - 1 + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let a = 0;
    let b = 1;
    let i = 0;
    while i < n {
        let t = a + b;
        a = b;
        b = t;
        i = i + 1;
    }
    return a;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64 -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1;
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n - deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n + 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(0);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(18);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n + 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(18);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(12);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n + 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(20);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n - deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(20);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(11);
    println(r;
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(1);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n + 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 2; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(17);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1;
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(17);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}

fn deep(n: i64 -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(15);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n - deep(n - 1);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = 2;
    while i <= n {
        s = s + i;
        i = i + 1;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(15);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(0;
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(7;
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(3);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(1);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(1);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n + 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(1);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n + deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64 -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n + 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 2);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return 1; }
    return n * deep(n - 1);
}
fn run(n: i64) -> i64 {
    let p = 1;
    let i = 2;
    while i <= n {
        p = p * i;
        i = i + 1;
    }
    return p;
}
fn main() -> i64 {
    let r = run(2);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(0);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n - deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n - deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(3);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(12);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(12);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64 -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(12);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(9);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(1);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(1);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(11);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2;
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n + 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(6);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main( -> i64 {
    let r = deep(6);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(16);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64 -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(14);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 3 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(13;
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return 1; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 1 {
        s = s + i;
        i = i - 2;
    }
    return s + 1;
}
fn main() -> i64 {
    let r = run(8);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(7);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n + 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(7);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(2);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main( -> i64 {
    let r = deep(2);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(8);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(11);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n + 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(11);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(9);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 1 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(9);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(5;
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(14);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(15);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(15);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(0);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64 -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(0);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(1);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(1);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(1;
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(13);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(13);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(10);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n + 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(10);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(4);
    println(r);
    return 0;
}

fn deep(n: i64 -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(4);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(3);
    println(r);
    return 0;
}

fn deep(n: i64 -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(3);
    println(r);
    return 0;
}


fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n + deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(16);
    println(r);
    return 0;
}

fn deep(n: i64) -> i64 {
    if n < 2 { return n; }
    return n - deep(n - 2);
}
fn run(n: i64) -> i64 {
    let s = 0;
    let i = n;
    while i > 0 {
        s = s + i;
        i = i - 2;
    }
    return s;
}
fn main() -> i64 {
    let r = deep(16);
    println(r);
    return 0;
}