You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: main.rs
    path of file: ./repos/aeneas/rust-scripts/src
    
    the code of the file until where you have to start completion: /// The following code generates the limits for the scalar types

fn test_modulo(x: i32, y: i32) {
    println!("{} % {} = {}", x, y, x % y);
}

fn main() {
    let ints_lower = [
        "isize", "i8", "i16", "i32", "i64", "i128", "usize", "u8", "u16", "u32", "u64", "u128",
    ];

    let ints_upper = [
        "Isize", "I8", "I16", "I32", "I64", "I128", "Usize", "U8", "U16", "U32", "U64", "U128",
    ];

    let can_fail_binops_lower = ["div", "rem", "add", "sub", "mul"];

    let mut ints_pairs = vec![];
    for i in 0..ints_lower.len() {
        ints_pairs.push((&ints_lower[i], &ints_upper[i]));
    }

    // Generate the code to print the scalar ranges
    for s in &ints_lower {
        println!(
            "println!(\"let {}_min = Z.of_string \\\"{{}}\\\"\", {}::MIN);",
            s, s
        );
        println!(
            "println!(\"let {}_max = Z.of_string \\\"{{}}\\\"\", {}::MAX);",
            s, s
        );
    }
    println!("\n");

    // Generate the OCaml definitions for the ranges - this code is
    // generated (comes from the above)
    println!("let isize_min = Z.of_string \"{}\"", isize::MIN);
    println!("let isize_max = Z.of_string \"{}\"", isize::MAX);
    println!("let i8_min = Z.of_string \"{}\"", i8::MIN);
    println!("let i8_max = Z.of_string \"{}\"", i8::MAX);
    println!("let i16_min = Z.of_string \"{}\"", i16::MIN);
    println!("let i16_max = Z.of_string \"{}\"", i16::MAX);
    println!("let i32_min = Z.of_string \"{}\"", i32::MIN);
    println!("let i32_max = Z.of_string \"{}\"", i32::MAX);
    println!("let i64_min = Z.of_string \"{}\"", i64::MIN);
    println!("let i64_max = Z.of_string \"{}\"", i64::MAX);
    println!("let i128_min = Z.of_string \"{}\"", i128::MIN);
    println!("let i128_max = Z.of_string \"{}\"", i128::MAX);
    println!("let usize_min = Z.of_string \"{}\"", usize::MIN);
    println!("let usize_max = Z.of_string \"{}\"", usize::MAX);
    println!("let u8_min = Z.of_string \"{}\"", u8::MIN);
    println!("let u8_max = Z.of_string \"{}\"", u8::MAX);
    println!("let u16_min = Z.of_string \"{}\"", u16::MIN);
    println!("let u16_max = Z.of_string \"{}\"", u16::MAX);
    println!("let u32_min = Z.of_string \"{}\"", u32::MIN);
    println!("let u32_max = Z.of_string \"{}\"", u32::MAX);
    println!("let u64_min = Z.of_string \"{}\"", u64::MIN);
    println!("let u64_max = Z.of_string \"{}\"", u64::MAX);
    println!("let u128_min = Z.of_string \"{}\"", u128::MIN);
    println!("let u128_max = Z.of_string \"{}\"", u128::MAX);
    println!("\n");

    // Generate the check_int_in_range body
    for (lo, up) in &ints_pairs {
        println!("| {} -> Z.leq {}_min i && Z.leq i {}_max", up, lo, lo);
    }
    println!("\n");

    // Generate the scalar_value_get_value_range body
    for s in &ints_upper {
        println!("| {} i -> i", s);
    }
    println!("\n");

    // Generate the mk_scalar body
    for s in &ints_upper {
        println!("| Types.{} -> Ok ({} i)", s, s);
    }
    println!("\n");

    // Generate the code to print the scalar ranges in F*
    for s in &ints_lower {
        println!("println!(\"let {}_min : int = {{}}\", {}::MIN);", s, s);
        println!("println!(\"let {}_max : int = {{}}\", {}::MAX);", s, s);
    }
    println!("\n");

    // Generate the F* definitions for the ranges - this code is
    // generated (comes from the above)
    println!("let isize_min : int = {}", isize::MIN);
    println!("let isize_max : int = {}", isize::MAX);
    println!("let i8_min : int = {}", i8::MIN);
    println!("let i8_max : int = {}", i8::MAX);
    println!("let i16_min : int = {}", i16::MIN);
    println!("let i16_max : int = {}", i16::MAX);
    println!("let i32_min : int = {}", i32::MIN);
    println!("let i32_max : int = {}", i32::MAX);
    println!("let i64_min : int = {}", i64::MIN);
    println!("let i64_max : int = {}", i64::MAX);
    println!("let i128_min : int = {}", i128::MIN);
    println!("let i128_max : int = {}", i128::MAX);
    println!("let usize_min : int = {}", usize::MIN);
    println!("let usize_max : int = {}", usize::MAX);
    println!("let u8_min : int = {}", u8::MIN);
    println!("let u8_max : int = {}", u8::MAX);
    println!("let u16_min : int = {}", u16::MIN);
    println!("let u16_max : int = {}", u16::MAX);
    println!("let u32_min : int = {}", u32::MIN);
    println!("let u32_max : int = {}", u32::MAX);
    println!("let u64_min : int = {}", u64::MIN);
    println!("let u64_max : i
    
fn main() {
    let ints_lower = [
        "isize", "i8", "i16", "i32", "i64", "i128", "usize", "u8", "u16", "u32", "u64", "u128",
    ];

    let ints_upper = [
        "Isize", "I8", "I16", "I32", "I64", "I128", "Usize", "U8", "U16", "U32", "U64", "U128",
    ];

    let can_fail_binops_lower = ["div", "rem", "add", "sub", "mul"];

    let mut ints_pairs = vec![];
    for i in 0..ints_lower.len() {
        ints_pairs.push((&ints_lower[i], &ints_upper[i]));
    }

    // Generate the code to print the scalar ranges
    for s in &ints_lower {
        println!(
            "println!(\"let {}_min = Z.of_string \\\"{{}}\\\"\", {}::MIN);",
            s, s
        );
        println!(
            "println!(\"let {}_max = Z.of_string \\\"{{}}\\\"\", {}::MAX);",
            s, s
        );
    }
    println!("\n");

    // Generate the OCaml definitions for the ranges - this code is
    // generated (comes from the above)
    println!("let isize_min = Z.of_string \"{}\"", isize::MIN);
    println!("let isize_max = Z.of_string \"{}\"", isize::MAX);
    println!("let i8_min = Z.of_string \"{}\"", i8::MIN);
    println!("let i8_max = Z.of_string \"{}\"", i8::MAX);
    println!("let i16_min = Z.of_string \"{}\"", i16::MIN);
    println!("let i16_max = Z.of_string \"{}\"", i16::MAX);
    println!("let i32_min = Z.of_string \"{}\"", i32::MIN);
    println!("let i32_max = Z.of_string \"{}\"", i32::MAX);
    println!("let i64_min = Z.of_string \"{}\"", i64::MIN);
    println!("let i64_max = Z.of_string \"{}\"", i64::MAX);
    println!("let i128_min = Z.of_string \"{}\"", i128::MIN);
    println!("let i128_max = Z.of_string \"{}\"", i128::MAX);
    println!("let usize_min = Z.of_string \"{}\"", usize::MIN);
    println!("let usize_max = Z.of_string \"{}\"", usize::MAX);
    println!("let u8_min = Z.of_string \"{}\"", u8::MIN);
    println!("let u8_max = Z.of_string \"{}\"", u8::MAX);
    println!("let u16_min = Z.of_string \"{}\"", u16::MIN);
    println!("let u16_max = Z.of_string \"{}\"", u16::MAX);
    println!("let u32_min = Z.of_string \"{}\"", u32::MIN);
    println!("let u32_max = Z.of_string \"{}\"", u32::MAX);
    println!("let u64_min = Z.of_string \"{}\"", u64::MIN);
    println!("let u64_max = Z.of_string \"{}\"", u64::MAX);
    println!("let u128_min = Z.of_string \"{}\"", u128::MIN);
    println!("let u128_max = Z.of_string \"{}\"", u128::MAX);
    println!("\n");

    // Generate the check_int_in_range body
    for (lo, up) in &ints_pairs {
        println!("| {} -> Z.leq {}_min i && Z.leq i {}_max", up, lo, lo);
    }
    println!("\n");

    // Generate the scalar_value_get_value_range body
    for s in &ints_upper {
        println!("| {} i -> i", s);
    }
    println!("\n");

    // Generate the mk_scalar body
    for s in &ints_upper {
        println!("| Types.{} -> Ok ({} i)", s, s);
    }
    println!("\n");

    // Generate the code to print the scalar ranges in F*
    for s in &ints_lower {
        println!("println!(\"let {}_min : int = {{}}\", {}::MIN);", s, s);
        println!("println!(\"let {}_max : int = {{}}\", {}::MAX);", s, s);
    }
    println!("\n");

    // Generate the F* definitions for the ranges - this code is
    // generated (comes from the above)
    println!("let isize_min : int = {}", isize::MIN);
    println!("let isize_max : int = {}", isize::MAX);
    println!("let i8_min : int = {}", i8::MIN);
    println!("let i8_max : int = {}", i8::MAX);
    println!("let i16_min : int = {}", i16::MIN);
    println!("let i16_max : int = {}", i16::MAX);
    println!("let i32_min : int = {}", i32::MIN);
    println!("let i32_max : int = {}", i32::MAX);
    println!("let i64_min : int = {}", i64::MIN);
    println!("let i64_max : int = {}", i64::MAX);
    println!("let i128_min : int = {}", i128::MIN);
    println!("let i128_max : int = {}", i128::MAX);
    println!("let usize_min : int = {}", usize::MIN);
    println!("let usize_max : int = {}", usize::MAX);
    println!("let u8_min : int = {}", u8::MIN);
    println!("let u8_max : int = {}", u8::MAX);
    println!("let u16_min : int = {}", u16::MIN);
    println!("let u16_max : int = {}", u16::MAX);
    println!("let u32_min : int = {}", u32::MIN);
    println!("let u32_max : int = {}", u32::MAX);
    println!("let u64_min : int = {}", u64::MIN);
    println!("let u64_max : int = {}", u64::MAX);
    println!("let u128_min : int = {}", u128::MIN);
    println!("let u128_max : int = {}", u128::MAX);
    println!("\n");

    // Generate the body for the ScalarTy definition
    for (_lo, up) in &ints_pairs {
        println!("| {}", up);
    }
    println!("\n");

    // Generate the body for the max/min F* functions
    for (lo, up) in &ints_pairs {
        println!("| {} -> {}_min", up, lo);
    }
    println!("\n");

    // Generate the scalar types for F*
    for (lo, up) in &ints_pairs {
        println!("type {} = scalar {}", lo, up);
    }
    println!("\n");

    // Generate the unops (rk.: we need to manually filter `-` applied on
    // unisgned numbers)
    for binop in &can_fail_binops_lower {
        for (lo, up) in &ints_pairs {
            println!("let {}_{} = scalar_{} #{}", lo, binop, binop, up);
        }
        println!("");
    }
    println!("\n");

    // Modulo tests
    test_modulo(1, 2);
    test_modulo(-1, 2);
    test_modulo(1, -2);
    test_modulo(-1, -2);
}