Function sha256_stack

bitvm/src/hash/sha256_u4_stack.rs:291–725

(
    stack: &mut StackTracker,
    num_bytes: u32,
    use_add_table: bool,
    use_full_xor: bool,
)

}

pub fn sha256_stack(
    stack: &mut StackTracker,
    num_bytes: u32,
    use_add_table: bool,
    use_full_xor: bool,
) -> Script {
    // up to 55 is one block and always supports add table
    // probably up to 68 bytes I can afford to load the add tables for the first chunk (but have I would have to unload it)

    let (mut padding_scripts, chunks) = double_padding(num_bytes);
    let mut bytes_per_chunk: Vec<u32> = Vec::new();
    let mut bytes_remaining = num_bytes;
    while bytes_remaining > 0 {
        if bytes_remaining > 64 {
            bytes_per_chunk.push(64);
            bytes_remaining -= 64;
        } else {
            bytes_per_chunk.push(bytes_remaining);
            bytes_remaining = 0;
        }
    }
    if bytes_per_chunk.len() < chunks as usize {
        bytes_per_chunk.push(0);
    }
    //println!("{:?}", bytes_per_chunk);
    //println!("{:?}", padding_scripts);

    let scheduling_64 = scheduling_64_padding();

    let mut message = (0..num_bytes * 2)
        .map(|i| stack.define(1, &format!("message[{}]", i)))
        .collect::<Vec<StackVariable>>();

    let (modulo, quotient) = match use_add_table {
        true => (
            u4_push_modulo_table_stack(stack),
            u4_push_quotient_table_stack(stack),
        ),
        false => (StackVariable::null(), StackVariable::null()),
    };

    stack.set_breakpoint("init");

    let shift_tables = u4_push_shift_tables_stack(stack);

    let (lookup, xor_table) = if use_full_xor {
        (
            u4_push_full_lookup_table_stack(stack),
            u4_push_full_xor_table_stack(stack),
        )
    } else {
        (
            u4_push_half_lookup_table_0_based_stack(stack),
            u4_push_half_xor_table_stack(stack),
        )
    };

    let mut varmap: HashMap<char, [StackVariable; 8]> = HashMap::new();