Function compress

bitvm/src/hash/blake3_utils.rs:472–517

(
    stack: &mut StackTracker,
    chaining: bool,
    counter: u32,
    block_len: u32,
    flags: u32,
    mut message: HashMap<u8, StackVariable>,
    tables: &TablesVars,
    final_rounds: u8,
  

/// Applies the blake3 compression function to the given 512 bit message, consumes everything and leaves only the final value
#[allow(clippy::too_many_arguments)]
pub(crate) fn compress(
    stack: &mut StackTracker,
    chaining: bool,
    counter: u32,
    block_len: u32,
    flags: u32,
    mut message: HashMap<u8, StackVariable>,
    tables: &TablesVars,
    final_rounds: u8,
    last_round: bool,
) {
    //chaining value needs to be copied for multiple blocks
    //every time that is provided

    // final_rounds must be 8, if you need more than 32 output bytes, you need to change this
    assert_eq!(final_rounds, 8);

    let mut state = init_state(stack, chaining, counter, block_len, flags);

    for _ in 0..6 {
        round(stack, &mut state, &message, tables, false);
        message = permutate(&message);
    }
    round(stack, &mut state, &message, tables, true); //Last iteration, consumes the message

    for i in (0..final_rounds).rev() {
        let mut tmp = Vec::new();

        //iterate nibbles
        for n in 0..8 {
            let v2 = *state.get(&(i + 8)).unwrap();
            let v1 = state.get_mut(&i).unwrap();
            tmp.push(xor_2_nibbles(stack, v1, v2, 0, n, tables.use_full_tables));

            if last_round && n % 2 == 1 {
                stack.to_altstack();
                stack.to_altstack();
            }
        }
        if !last_round {
            for _ in 0..8 {
                stack.to_altstack();
            }
        }
    }
}

pub(crate) fn get_flags_for_block(i: u32, num_blocks: u32) -> u32 {
    if num_blocks == 1 {