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

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

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


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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = a;
    while i <= b {
        let t = b - i;
        s = s + t;
        i = i + 2;
    }
    return s;
}
fn main() -> i64 {
    let r = run(5, 6);
    println(r);
    return 0;
}


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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