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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s - i;
        i = i - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(8, 13);
    println(r);
    return 0;
}


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s - i;
        i = i - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(12, 14);
    println(r);
    return 0;
}


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

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


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

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


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

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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


fn run(a: i64, b: i64) -> i64 {
    let s = 0;
    let i = b;
    while i >= a {
        s = s + i;
        i = i - 1;
    }
    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 = b;
    while i >= a {
        let t = i;
        s = s + t;
        i = i - 1;
    }
    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 = b;
    while i >= a {
        s = s - i;
        i = i - 1;
    }
    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 = b;
    while i >= a {
        s = s + i;
        i = i - 1;
    }
    return s;
}
fn main() -> i64 {
    let r = run(14, 2);
    println(r);
    return 0;
}

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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


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

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


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

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