sha256_mem_impl.hpp

Go to the documentation of this file.

// AUTOGENERATED FILE
#pragma once
 
#include "barretenberg/vm2/generated/relations/sha256_mem.hpp"
 
namespace bb::avm2 {
 
template <typename FF_>
template <typename ContainerOverSubrelations, typename AllEntities>
void sha256_memImpl<FF_>::accumulate(ContainerOverSubrelations& evals,
                                     const AllEntities& in,
                                     [[maybe_unused]] const RelationParameters<FF_>&,
                                     [[maybe_unused]] const FF_& scaling_factor)
{
    using C = ColumnAndShifts;
 
    PROFILE_THIS_NAME("accumulate/sha256_mem");
 
    const auto constants_MEM_TAG_U32 = FF(4);
    const auto constants_AVM_HIGHEST_MEM_ADDRESS = FF(4294967295UL);
    const auto sha256_LATCH_CONDITION = in.get(C::sha256_latch) + in.get(C::precomputed_first_row);
    const auto sha256_STATE_READ_CONDITION = in.get(C::sha256_start) * (FF(1) - in.get(C::sha256_mem_out_of_range_err));
    const auto sha256_OUTPUT_WRITE_CONDITION = in.get(C::sha256_latch) * (FF(1) - in.get(C::sha256_err));
    const auto sha256_MEM_ADDR = sha256_STATE_READ_CONDITION * in.get(C::sha256_state_addr) +
                                 sha256_OUTPUT_WRITE_CONDITION * in.get(C::sha256_output_addr);
    const auto sha256_STATE_TAG_DIFF_0 = (in.get(C::sha256_memory_tag_0_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_1 = (in.get(C::sha256_memory_tag_1_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_2 = (in.get(C::sha256_memory_tag_2_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_3 = (in.get(C::sha256_memory_tag_3_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_4 = (in.get(C::sha256_memory_tag_4_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_5 = (in.get(C::sha256_memory_tag_5_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_6 = (in.get(C::sha256_memory_tag_6_) - constants_MEM_TAG_U32);
    const auto sha256_STATE_TAG_DIFF_7 = (in.get(C::sha256_memory_tag_7_) - constants_MEM_TAG_U32);
    const auto sha256_BATCHED_TAG_CHECK = FF(1) * sha256_STATE_TAG_DIFF_0 + FF(8) * sha256_STATE_TAG_DIFF_1 +
                                          FF(64) * sha256_STATE_TAG_DIFF_2 + FF(512) * sha256_STATE_TAG_DIFF_3 +
                                          FF(4096) * sha256_STATE_TAG_DIFF_4 + FF(32768) * sha256_STATE_TAG_DIFF_5 +
                                          FF(262144) * sha256_STATE_TAG_DIFF_6 + FF(2097152) * sha256_STATE_TAG_DIFF_7;
    const auto sha256_INPUT_TAG_DIFF =
        in.get(C::sha256_sel_read_input_from_memory) * (in.get(C::sha256_input_tag) - constants_MEM_TAG_U32);
    const auto sha256_LATCH_ON_ERROR = (FF(1) - (FF(1) - in.get(C::sha256_mem_out_of_range_err)) *
                                                    (FF(1) - in.get(C::sha256_sel_invalid_state_tag_err)) *
                                                    (FF(1) - in.get(C::sha256_sel_invalid_input_row_tag_err)));
 
    {
        using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel) * (FF(1) - in.get(C::sha256_sel));
        tmp *= scaling_factor;
        std::get<0>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<1, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_start) * (FF(1) - in.get(C::sha256_sel));
        tmp *= scaling_factor;
        std::get<1>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<2, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_latch) * (FF(1) - in.get(C::sha256_latch));
        tmp *= scaling_factor;
        std::get<2>(evals) += typename Accumulator::View(tmp);
    }
    { // LATCH_HAS_SEL_ON
        using Accumulator = typename std::tuple_element_t<3, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_latch) * (FF(1) - in.get(C::sha256_sel));
        tmp *= scaling_factor;
        std::get<3>(evals) += typename Accumulator::View(tmp);
    }
    { // START_AFTER_LAST
        using Accumulator = typename std::tuple_element_t<4, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_shift) * (in.get(C::sha256_start_shift) - sha256_LATCH_CONDITION);
        tmp *= scaling_factor;
        std::get<4>(evals) += typename Accumulator::View(tmp);
    }
    { // CONTINUITY_SEL
        using Accumulator = typename std::tuple_element_t<5, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) * (in.get(C::sha256_sel_shift) - in.get(C::sha256_sel));
        tmp *= scaling_factor;
        std::get<5>(evals) += typename Accumulator::View(tmp);
    }
    { // CONTINUITY_EXEC_CLK
        using Accumulator = typename std::tuple_element_t<6, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) *
                   (in.get(C::sha256_execution_clk_shift) - in.get(C::sha256_execution_clk));
        tmp *= scaling_factor;
        std::get<6>(evals) += typename Accumulator::View(tmp);
    }
    { // CONTINUITY_SPACE_ID
        using Accumulator = typename std::tuple_element_t<7, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) * (in.get(C::sha256_space_id_shift) - in.get(C::sha256_space_id));
        tmp *= scaling_factor;
        std::get<7>(evals) += typename Accumulator::View(tmp);
    }
    { // CONTINUITY_OUTPUT_ADDR
        using Accumulator = typename std::tuple_element_t<8, ContainerOverSubrelations>;
        auto tmp =
            (FF(1) - sha256_LATCH_CONDITION) * (in.get(C::sha256_output_addr_shift) - in.get(C::sha256_output_addr));
        tmp *= scaling_factor;
        std::get<8>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<9, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_start) * (in.get(C::sha256_max_mem_addr) - constants_AVM_HIGHEST_MEM_ADDRESS);
        tmp *= scaling_factor;
        std::get<9>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<10, ContainerOverSubrelations>;
        auto tmp =
            (in.get(C::sha256_max_state_addr) - in.get(C::sha256_start) * (in.get(C::sha256_state_addr) + FF(7)));
        tmp *= scaling_factor;
        std::get<10>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<11, ContainerOverSubrelations>;
        auto tmp =
            (in.get(C::sha256_max_input_addr) - in.get(C::sha256_start) * (in.get(C::sha256_input_addr) + FF(15)));
        tmp *= scaling_factor;
        std::get<11>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<12, ContainerOverSubrelations>;
        auto tmp =
            (in.get(C::sha256_max_output_addr) - in.get(C::sha256_start) * (in.get(C::sha256_output_addr) + FF(7)));
        tmp *= scaling_factor;
        std::get<12>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<13, ContainerOverSubrelations>;
        auto tmp = (in.get(C::sha256_mem_out_of_range_err) -
                    (FF(1) - (FF(1) - in.get(C::sha256_sel_state_out_of_range_err)) *
                                 (FF(1) - in.get(C::sha256_sel_input_out_of_range_err)) *
                                 (FF(1) - in.get(C::sha256_sel_output_out_of_range_err))));
        tmp *= scaling_factor;
        std::get<13>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<14, ContainerOverSubrelations>;
        auto tmp = (in.get(C::sha256_u32_tag) - in.get(C::sha256_sel) * constants_MEM_TAG_U32);
        tmp *= scaling_factor;
        std::get<14>(evals) += typename Accumulator::View(tmp);
    }
    { // START_OR_LAST_MEM
        using Accumulator = typename std::tuple_element_t<15, ContainerOverSubrelations>;
        auto tmp =
            (in.get(C::sha256_sel_mem_state_or_output) - (sha256_STATE_READ_CONDITION + sha256_OUTPUT_WRITE_CONDITION));
        tmp *= scaling_factor;
        std::get<15>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<16, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_0_) - (sha256_MEM_ADDR + FF(0)));
        tmp *= scaling_factor;
        std::get<16>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<17, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_1_) - (sha256_MEM_ADDR + FF(1)));
        tmp *= scaling_factor;
        std::get<17>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<18, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_2_) - (sha256_MEM_ADDR + FF(2)));
        tmp *= scaling_factor;
        std::get<18>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<19, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_3_) - (sha256_MEM_ADDR + FF(3)));
        tmp *= scaling_factor;
        std::get<19>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<20, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_4_) - (sha256_MEM_ADDR + FF(4)));
        tmp *= scaling_factor;
        std::get<20>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<21, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_5_) - (sha256_MEM_ADDR + FF(5)));
        tmp *= scaling_factor;
        std::get<21>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<22, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_6_) - (sha256_MEM_ADDR + FF(6)));
        tmp *= scaling_factor;
        std::get<22>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<23, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_mem_state_or_output) *
                   (in.get(C::sha256_memory_address_7_) - (sha256_MEM_ADDR + FF(7)));
        tmp *= scaling_factor;
        std::get<23>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<24, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_0_) - in.get(C::sha256_init_a)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_0_) - in.get(C::sha256_output_a_rhs)));
        tmp *= scaling_factor;
        std::get<24>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<25, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_1_) - in.get(C::sha256_init_b)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_1_) - in.get(C::sha256_output_b_rhs)));
        tmp *= scaling_factor;
        std::get<25>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<26, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_2_) - in.get(C::sha256_init_c)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_2_) - in.get(C::sha256_output_c_rhs)));
        tmp *= scaling_factor;
        std::get<26>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<27, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_3_) - in.get(C::sha256_init_d)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_3_) - in.get(C::sha256_output_d_rhs)));
        tmp *= scaling_factor;
        std::get<27>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<28, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_4_) - in.get(C::sha256_init_e)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_4_) - in.get(C::sha256_output_e_rhs)));
        tmp *= scaling_factor;
        std::get<28>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<29, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_5_) - in.get(C::sha256_init_f)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_5_) - in.get(C::sha256_output_f_rhs)));
        tmp *= scaling_factor;
        std::get<29>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<30, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_6_) - in.get(C::sha256_init_g)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_6_) - in.get(C::sha256_output_g_rhs)));
        tmp *= scaling_factor;
        std::get<30>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<31, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_mem_state_or_output) *
            (sha256_STATE_READ_CONDITION * (in.get(C::sha256_memory_register_7_) - in.get(C::sha256_init_h)) +
             sha256_OUTPUT_WRITE_CONDITION * (in.get(C::sha256_memory_register_7_) - in.get(C::sha256_output_h_rhs)));
        tmp *= scaling_factor;
        std::get<31>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<32, ContainerOverSubrelations>;
        auto tmp = (in.get(C::sha256_rw) - sha256_OUTPUT_WRITE_CONDITION);
        tmp *= scaling_factor;
        std::get<32>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<33, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_invalid_state_tag_err) * (FF(1) - in.get(C::sha256_sel_invalid_state_tag_err));
        tmp *= scaling_factor;
        std::get<33>(evals) += typename Accumulator::View(tmp);
    }
    { // BATCH_ZERO_CHECK_READ
        using Accumulator = typename std::tuple_element_t<34, ContainerOverSubrelations>;
        auto tmp =
            (sha256_STATE_READ_CONDITION * sha256_BATCHED_TAG_CHECK *
                 ((FF(1) - in.get(C::sha256_sel_invalid_state_tag_err)) * (FF(1) - in.get(C::sha256_batch_tag_inv)) +
                  in.get(C::sha256_batch_tag_inv)) -
             in.get(C::sha256_sel_invalid_state_tag_err));
        tmp *= scaling_factor;
        std::get<34>(evals) += typename Accumulator::View(tmp);
    }
    { // BATCH_ENFORCE_ZERO_WRITE
        using Accumulator = typename std::tuple_element_t<35, ContainerOverSubrelations>;
        auto tmp = sha256_OUTPUT_WRITE_CONDITION * sha256_BATCHED_TAG_CHECK;
        tmp *= scaling_factor;
        std::get<35>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<36, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_is_input_round) * (FF(1) - in.get(C::sha256_sel_is_input_round));
        tmp *= scaling_factor;
        std::get<36>(evals) += typename Accumulator::View(tmp);
    }
    { // SEL_IS_INPUT_ROUND_START_COND
        using Accumulator = typename std::tuple_element_t<37, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_start) * (in.get(C::sha256_sel_is_input_round) - FF(1));
        tmp *= scaling_factor;
        std::get<37>(evals) += typename Accumulator::View(tmp);
    }
    { // SEL_IS_INPUT_END
        using Accumulator = typename std::tuple_element_t<38, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) *
                   (in.get(C::sha256_input_rounds_rem) * ((FF(1) - in.get(C::sha256_sel_is_input_round)) *
                                                              (FF(1) - in.get(C::sha256_input_rounds_rem_inv)) +
                                                          in.get(C::sha256_input_rounds_rem_inv)) -
                    in.get(C::sha256_sel_is_input_round));
        tmp *= scaling_factor;
        std::get<38>(evals) += typename Accumulator::View(tmp);
    }
    { // SEL_IS_INPUT_PROPAGATE
        using Accumulator = typename std::tuple_element_t<39, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) * (FF(1) - in.get(C::sha256_sel_is_input_round)) *
                   in.get(C::sha256_sel_is_input_round_shift);
        tmp *= scaling_factor;
        std::get<39>(evals) += typename Accumulator::View(tmp);
    }
    { // INPUT_ROUND_CTR_START_COND
        using Accumulator = typename std::tuple_element_t<40, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_start) * (in.get(C::sha256_input_rounds_rem) - FF(16));
        tmp *= scaling_factor;
        std::get<40>(evals) += typename Accumulator::View(tmp);
    }
    { // INPUT_ROUND_CTR_DECR_COND
        using Accumulator = typename std::tuple_element_t<41, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel) * (FF(1) - sha256_LATCH_CONDITION) *
                   (in.get(C::sha256_input_rounds_rem_shift) -
                    (in.get(C::sha256_input_rounds_rem) - in.get(C::sha256_sel_is_input_round)));
        tmp *= scaling_factor;
        std::get<41>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<42, ContainerOverSubrelations>;
        auto tmp = (in.get(C::sha256_sel_read_input_from_memory) -
                    in.get(C::sha256_sel) * (FF(1) - in.get(C::sha256_mem_out_of_range_err)) *
                        in.get(C::sha256_sel_is_input_round) * (FF(1) - in.get(C::sha256_sel_invalid_state_tag_err)));
        tmp *= scaling_factor;
        std::get<42>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<43, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_is_input_round) * (in.get(C::sha256_input) - in.get(C::sha256_w));
        tmp *= scaling_factor;
        std::get<43>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<44, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel_invalid_input_tag_err) * (FF(1) - in.get(C::sha256_sel_invalid_input_tag_err));
        tmp *= scaling_factor;
        std::get<44>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<45, ContainerOverSubrelations>;
        auto tmp =
            in.get(C::sha256_sel_invalid_input_row_tag_err) * (FF(1) - in.get(C::sha256_sel_invalid_input_row_tag_err));
        tmp *= scaling_factor;
        std::get<45>(evals) += typename Accumulator::View(tmp);
    }
    { // INPUT_TAG_DIFF_CHECK
        using Accumulator = typename std::tuple_element_t<46, ContainerOverSubrelations>;
        auto tmp = (sha256_INPUT_TAG_DIFF * ((FF(1) - in.get(C::sha256_sel_invalid_input_row_tag_err)) *
                                                 (FF(1) - in.get(C::sha256_input_tag_diff_inv)) +
                                             in.get(C::sha256_input_tag_diff_inv)) -
                    in.get(C::sha256_sel_invalid_input_row_tag_err));
        tmp *= scaling_factor;
        std::get<46>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<47, ContainerOverSubrelations>;
        auto tmp = in.get(C::sha256_sel) * sha256_LATCH_ON_ERROR * (in.get(C::sha256_latch) - FF(1));
        tmp *= scaling_factor;
        std::get<47>(evals) += typename Accumulator::View(tmp);
    }
    { // TAG_ERROR_INIT
        using Accumulator = typename std::tuple_element_t<48, ContainerOverSubrelations>;
        auto tmp = sha256_LATCH_CONDITION *
                   (in.get(C::sha256_sel_invalid_input_tag_err) - in.get(C::sha256_sel_invalid_input_row_tag_err));
        tmp *= scaling_factor;
        std::get<48>(evals) += typename Accumulator::View(tmp);
    }
    { // TAG_ERROR_PROPAGATION
        using Accumulator = typename std::tuple_element_t<49, ContainerOverSubrelations>;
        auto tmp = (FF(1) - sha256_LATCH_CONDITION) *
                   (in.get(C::sha256_sel_invalid_input_tag_err) - in.get(C::sha256_sel_invalid_input_tag_err_shift));
        tmp *= scaling_factor;
        std::get<49>(evals) += typename Accumulator::View(tmp);
    }
    {
        using Accumulator = typename std::tuple_element_t<50, ContainerOverSubrelations>;
        auto tmp = (in.get(C::sha256_err) - (FF(1) - (FF(1) - in.get(C::sha256_mem_out_of_range_err)) *
                                                         (FF(1) - in.get(C::sha256_sel_invalid_state_tag_err)) *
                                                         (FF(1) - in.get(C::sha256_sel_invalid_input_tag_err))));
        tmp *= scaling_factor;
        std::get<50>(evals) += typename Accumulator::View(tmp);
    }
}
 
} // namespace bb::avm2