/**
 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// NOLINTNEXTLINE(misc-definitions-in-headers,readability-function-size)
inline void AdjustFlags([[maybe_unused]] RuntimeInterface::IntrinsicId intrinsic, [[maybe_unused]] Inst *inst)
{
    // Note: code relies on current intrinsic instruction default flags
    switch (intrinsic)
    {
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_ABS_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_ABS_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_ABS_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_ABS_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_ABS_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_ABS_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_ABS_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_ABS_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MIN_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MIN_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MIN_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MIN_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MIN_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MIN_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MIN_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MIN_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MAX_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MAX_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MAX_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MAX_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MAX_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MAX_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_MAX_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_MAX_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_DOUBLE_IS_INF:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "DOUBLE_IS_INF CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_FLOAT_IS_INF:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "FLOAT_IS_INF CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_SIN_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_SIN_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_SIN_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_SIN_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_COS_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_COS_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_COS_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_COS_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_POW_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_POW_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_POW_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_POW_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_SQRT_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_SQRT_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_SQRT_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_SQRT_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_CALCULATE_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_CALCULATE_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MATH_CALCULATE_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MATH_CALCULATE_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_U32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_U32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_IO_PRINT_U64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "IO_PRINT_U64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SYSTEM_EXIT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SYSTEM_EXIT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SYSTEM_NANO_TIME:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SYSTEM_NANO_TIME CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SYSTEM_ASSERT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SYSTEM_ASSERT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SYSTEM_ASSERT_PRINT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SYSTEM_ASSERT_PRINT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHECK_TAG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CHECK_TAG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_U32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_U32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_U64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_U64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CONVERT_STRING_TO_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CONVERT_STRING_TO_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_OBJECT_CREATE_NON_MOVABLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "OBJECT_CREATE_NON_MOVABLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_OBJECT_NOTIFY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "OBJECT_NOTIFY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_OBJECT_NOTIFY_ALL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "OBJECT_NOTIFY_ALL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_NATIVE_METHOD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::CALL|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_NATIVE_METHOD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_NATIVE_METHOD_MANAGED_CLASS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CALL|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_NATIVE_METHOD_MANAGED_CLASS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_METHOD_NATIVE_POINTER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CALL|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_METHOD_NATIVE_POINTER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_NATIVE_API_ENV:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CALL|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_NATIVE_API_ENV CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_BEGIN_NATIVE_METHOD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_BEGIN_NATIVE_METHOD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_END_NATIVE_METHOD_PRIM:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_END_NATIVE_METHOD_PRIM CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_END_NATIVE_METHOD_OBJ:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_END_NATIVE_METHOD_OBJ CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CHECK_NATIVE_EXCEPTION:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::ACC_WRITE|compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CHECK_NATIVE_EXCEPTION CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SLOW_PATH_ENTRY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SLOW_PATH_ENTRY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_SAVE_REGISTERS_EP:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "SAVE_REGISTERS_EP CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_RESTORE_REGISTERS_EP:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "RESTORE_REGISTERS_EP CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNREACHABLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::TERMINATOR;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNREACHABLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "UNREACHABLE cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_TAIL_CALL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::TERMINATOR|compiler::inst_flags::NO_DST;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "TAIL_CALL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "TAIL_CALL cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INTERPRETER_RETURN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INTERPRETER_RETURN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INIT_INTERPRETER_CALL_RECORD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INIT_INTERPRETER_CALL_RECORD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_PUSH_INTERPRETER_CALL_RECORD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "PUSH_INTERPRETER_CALL_RECORD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_POP_INTERPRETER_CALL_RECORD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "POP_INTERPRETER_CALL_RECORD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_POP_MULTIPLE_INTERPRETER_CALL_RECORDS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "POP_MULTIPLE_INTERPRETER_CALL_RECORDS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UPDATE_INTERPRETER_CALL_RECORD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UPDATE_INTERPRETER_CALL_RECORD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_LOAD_ACQUIRE_MARK_WORD_EXCLUSIVE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "LOAD_ACQUIRE_MARK_WORD_EXCLUSIVE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STORE_RELEASE_MARK_WORD_EXCLUSIVE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STORE_RELEASE_MARK_WORD_EXCLUSIVE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPARE_AND_SET_MARK_WORD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPARE_AND_SET_MARK_WORD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_DATA_MEMORY_BARRIER_FULL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "DATA_MEMORY_BARRIER_FULL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_WRITE_TLAB_STATS_SAFE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "WRITE_TLAB_STATS_SAFE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_BYTES_U64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "REVERSE_BYTES_U64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_BYTES_U32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "REVERSE_BYTES_U32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_HALF_WORDS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "REVERSE_HALF_WORDS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COUNT_LEADING_ZERO_BITS_U64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COUNT_LEADING_ZERO_BITS_U64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_EXPAND_U8_TO_U16:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "EXPAND_U8_TO_U16 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_ATOMIC_BYTE_OR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "ATOMIC_BYTE_OR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPRESS_EIGHT_UTF16_TO_UTF8_CHARS_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPRESS_EIGHT_UTF16_TO_UTF8_CHARS_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPRESS_SIXTEEN_UTF16_TO_UTF8_CHARS_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPRESS_SIXTEEN_UTF16_TO_UTF8_CHARS_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U8_X32_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_CHAR_U8_X32_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_CHAR_U8_X32_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U8_X16_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_CHAR_U8_X16_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_CHAR_U8_X16_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U16_X16_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_CHAR_U16_X16_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_CHAR_U16_X16_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U16_X8_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_CHAR_U16_X8_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_CHAR_U16_X8_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_LAST_CHAR_U16_X8_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_LAST_CHAR_U16_X8_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_LAST_CHAR_U16_X8_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_LAST_CHAR_U8_X16_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "MEM_LAST_CHAR_U8_X16_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "MEM_LAST_CHAR_U8_X16_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_UPPER_CASE_U8_X16_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CHARS_TO_UPPER_CASE_U8_X16_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "CHARS_TO_UPPER_CASE_U8_X16_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_UPPER_CASE_U8_X8_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CHARS_TO_UPPER_CASE_U8_X8_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "CHARS_TO_UPPER_CASE_U8_X8_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_LOWER_CASE_U8_X16_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CHARS_TO_LOWER_CASE_U8_X16_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "CHARS_TO_LOWER_CASE_U8_X16_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_LOWER_CASE_U8_X8_USING_SIMD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "CHARS_TO_LOWER_CASE_U8_X8_USING_SIMD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "CHARS_TO_LOWER_CASE_U8_X8_USING_SIMD cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_CAST_DOUBLE_TO_CHAR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_CAST_DOUBLE_TO_CHAR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_SIN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_SIN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_COS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_COS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_POWER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_POWER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_SQRT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_SQRT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ABS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ABS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ABS_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ABS_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ABS_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ABS_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ABS_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ABS_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MAX_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MAX_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MAX_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MAX_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MAX_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MAX_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MAX_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MAX_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MIN_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MIN_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MIN_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MIN_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MIN_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MIN_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MIN_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MIN_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ACOS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ACOS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ACOS_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ACOS_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ACOSH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ACOSH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ACOSH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ACOSH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ASIN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ASIN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ASIN_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ASIN_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ASINH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ASINH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ASINH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ASINH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATAN2:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATAN2 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATAN2_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATAN2_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATANH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATANH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATANH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATANH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ATAN_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ATAN_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_SINH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_SINH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_SINH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_SINH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_COSH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_COSH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_COSH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_COSH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_FLOOR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_FLOOR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_ROUND:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_ROUND CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_TRUNC:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_TRUNC CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CBRT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CBRT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CBRT_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CBRT_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_TAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_TAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_TAN_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_TAN_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_TANH:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_TANH CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_TANH_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_TANH_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_EXP:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_EXP CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_EXP_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_EXP_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_LOG10:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_LOG10 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_LOG10_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_LOG10_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_EXPM1:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_EXPM1 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_EXPM1_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_EXPM1_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CEIL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CEIL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_LOG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_LOG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_LOG_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_LOG_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_REM:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_REM CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_MOD:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_MOD CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CLZ64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CLZ64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CLZ32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CLZ32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_CLZ32_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_CLZ32_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_SIGNBIT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_SIGNBIT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_IMUL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_IMUL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_FROUND:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_FROUND CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_HYPOT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_HYPOT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_MATH_HYPOT_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_MATH_HYPOT_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SB_APPEND_STRING:
    {
        constexpr auto CLEAR_FLAGS = 0U;
        constexpr auto SET_FLAGS = compiler::inst_flags::REQUIRE_TMP;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SB_APPEND_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "STD_CORE_SB_APPEND_STRING cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_MATH_MAX:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_MATH_MAX CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_MATH_MIN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_MATH_MIN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_ESCOMPAT_ARRAY_IS_PLATFORM_ARRAY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "ESCOMPAT_ARRAY_IS_PLATFORM_ARRAY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_ESCOMPAT_ARRAY_GET_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "ESCOMPAT_ARRAY_GET_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT8_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT8_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT16_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT16_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT32_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT32_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_BIG_INT64_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "BIG_INT64_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_FLOAT32_ARRA_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "FLOAT32_ARRA_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_FLOAT64_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "FLOAT64_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_U_INT8_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "U_INT8_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_U_INT8_CLAMPED_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "U_INT8_CLAMPED_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_U_INT16_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "U_INT16_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_U_INT32_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "U_INT32_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_BIG_U_INT64_ARRAY_REVERSE_COPY_BUFFER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "BIG_U_INT64_ARRAY_REVERSE_COPY_BUFFER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_TIME_DATE_NANO_NOW:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_TIME_DATE_NANO_NOW CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_TIME_CHRONO_GET_CPU_TIME:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_TIME_CHRONO_GET_CPU_TIME CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_IS_NAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_IS_NAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_IS_FINITE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_IS_FINITE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_BIT_CAST_FROM_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_BIT_CAST_FROM_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_BIT_CAST_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_BIT_CAST_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_IS_INTEGER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_IS_INTEGER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_FLOAT_IS_SAFE_INTEGER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_FLOAT_IS_SAFE_INTEGER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_TO_SHORT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_FLOAT_TO_SHORT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_TO_BYTE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_FLOAT_TO_BYTE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_FLOAT_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_FLOAT_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_TO_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_FLOAT_TO_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_IS_NAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_IS_NAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_IS_FINITE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_IS_FINITE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_BIT_CAST_FROM_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_BIT_CAST_FROM_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_BIT_CAST_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_BIT_CAST_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_IS_INTEGER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_IS_INTEGER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_DOUBLE_IS_SAFE_INTEGER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_DOUBLE_IS_SAFE_INTEGER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_TO_SHORT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_DOUBLE_TO_SHORT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_TO_BYTE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_DOUBLE_TO_BYTE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT32_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT32_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT16_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT16_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_INT8_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "INT8_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UINT32_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UINT32_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UINT16_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UINT16_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UINT8_ARRAY_DOUBLE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UINT8_ARRAY_DOUBLE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_DOUBLE_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_TO_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_DOUBLE_TO_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_INT8:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_INT8 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_INT16:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_INT16 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_INT32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_INT32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_INT64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_INT64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_FLOAT32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_FLOAT32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_FLOAT64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_FLOAT64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_NUMBER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_NUMBER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_WRITE_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_INT8:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_INT8 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_INT16:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_INT16 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_INT32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_INT32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_INT64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_INT64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_FLOAT32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_FLOAT32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_FLOAT64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_FLOAT64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_NUMBER:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_READ_NUMBER CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_GET_STRING_SIZE_IN_BYTES:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "UNSAFE_MEMORY_GET_STRING_SIZE_IN_BYTES CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STACK_TRACE_LINES:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_STACK_TRACE_LINES CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STACK_TRACE_PROVISION_STACK_TRACE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_STACK_TRACE_PROVISION_STACK_TRACE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_EXIT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_EXIT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_RUNTIME_GET_TYPE_INFO:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_RUNTIME_GET_TYPE_INFO CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_IS_UPPER_CASE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_CHAR_IS_UPPER_CASE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_TO_UPPER_CASE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_CHAR_TO_UPPER_CASE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_IS_LOWER_CASE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_CHAR_IS_LOWER_CASE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_TO_LOWER_CASE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_CHAR_TO_LOWER_CASE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_IS_WHITE_SPACE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_CHAR_IS_WHITE_SPACE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_SHORT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_SHORT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_TO_CHAR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_BYTE_TO_CHAR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_BYTE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_BYTE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_TO_CHAR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_SHORT_TO_CHAR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_SHORT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_SHORT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_BYTE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_BYTE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_LONG:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_LONG CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_TO_CHAR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_INT_TO_CHAR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_SHORT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_SHORT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_BYTE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_BYTE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_FLOAT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_FLOAT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_TO_CHAR:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_HOIST|compiler::inst_flags::NO_CSE|compiler::inst_flags::BARRIER|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::RUNTIME_CALL|compiler::inst_flags::HEAP_INV|compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "STD_CORE_LONG_TO_CHAR CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_FINALIZATION_REGISTRY_CALLBACK:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_FINALIZATION_REGISTRY_CALLBACK CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_NEW_JS_VALUE_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_NEW_JS_VALUE_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_NEW_JS_VALUE_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_NEW_JS_VALUE_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_NEW_JS_VALUE_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_NEW_JS_VALUE_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_NEW_JS_VALUE_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_NEW_JS_VALUE_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_IS_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_IS_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_NEW_JS_VALUE_BIG_INT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_NEW_JS_VALUE_BIG_INT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_VALUE_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_VALUE_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_VALUE_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_VALUE_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_VALUE_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_VALUE_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_VALUE_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_CSE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_VALUE_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_JS_VALUE_BY_KEY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_JS_VALUE_BY_KEY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_PROPERTY_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_PROPERTY_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_PROPERTY_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_PROPERTY_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIMESET_PROPERTY_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIMESET_PROPERTY_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_ELEMENT_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_ELEMENT_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_ELEMENT_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_ELEMENT_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_PROPERTY_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_PROPERTY_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_PROPERTY_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_PROPERTY_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_PROPERTY_BOOLEAN:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_PROPERTY_BOOLEAN CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_ELEMENT_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_ELEMENT_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_ELEMENT_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_ELEMENT_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_ELEMENT_DOUBLE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_ELEMENT_DOUBLE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_UNDEFINED:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_UNDEFINED CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_NULL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_NULL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_GET_GLOBAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_GET_GLOBAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_CREATE_OBJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_CREATE_OBJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_CREATE_ARRAY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_CREATE_ARRAY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_INSTANCE_OF_DYNAMIC:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_INSTANCE_OF_DYNAMIC CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_INSTANCE_OF_STATIC:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_INSTANCE_OF_STATIC CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_INIT_JS_CALL_CLASS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_INIT_JS_CALL_CLASS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_INIT_JS_NEW_CLASS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_INIT_JS_NEW_CLASS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_LOAD_MODULE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_LOAD_MODULE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_STRICT_EQUAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_STRICT_EQUAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_SET_PROPERTY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_SET_PROPERTY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_RUNTIME_IS_STATIC_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JS_RUNTIME_IS_STATIC_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_JSON_STRINGIFY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "JSON_STRINGIFY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_JS_NAMED_PROPERTY:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_JS_NAMED_PROPERTY CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_GET_JS_ELEMENT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_GET_JS_ELEMENT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_RESOLVE_QUALIFIED_JS_CALL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_RESOLVE_QUALIFIED_JS_CALL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_LOAD_RESOLVED_JS_FUNCTION:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_LOAD_RESOLVED_JS_FUNCTION CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_CALL_CHECK:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_JS_CALL_CHECK CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_CALL_FUNCTION:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_JS_CALL_FUNCTION CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_CALL_VOID_FUNCTION:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_JS_CALL_VOID_FUNCTION CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_NEW_INSTANCE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_JS_NEW_INSTANCE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CREATE_LOCAL_SCOPE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CREATE_LOCAL_SCOPE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_DESTROY_LOCAL_SCOPE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_DESTROY_LOCAL_SCOPE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_LOAD_JS_CONSTANT_POOL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_LOAD_JS_CONSTANT_POOL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_INIT_JS_CALL_CLASS_FOR_CTX:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_CSE|compiler::inst_flags::NO_HOIST;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_INIT_JS_CALL_CLASS_FOR_CTX CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_VOID_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_VOID_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_U1_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_U1_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_U8_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_U8_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_I8_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_I8_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_U16_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_U16_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_I16_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_I16_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_U32_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_U32_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_I32_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_I32_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_U64_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_U64_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_I64_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_I64_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_F32_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_F32_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_F64_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_F64_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_REF_TYPE_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_REF_TYPE_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_JS_VALUE_TO_LOCAL:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_JS_VALUE_TO_LOCAL CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_U1:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_U1 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_U8:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_U8 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_I8:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_I8 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_U16:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_U16 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_I16:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_I16 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_U32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_U32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_U64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_U64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_JS_VALUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::NO_DCE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_JS_VALUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_STRING:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_STRING CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_CONVERT_LOCAL_TO_REF_TYPE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_CONVERT_LOCAL_TO_REF_TYPE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_PROMISE_INTEROP_RESOLVE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "PROMISE_INTEROP_RESOLVE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_PROMISE_INTEROP_REJECT:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::CAN_THROW;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "PROMISE_INTEROP_REJECT CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_LD_OBJ_BY_NAME_OBJ:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_LD_OBJ_BY_NAME_OBJ CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_LD_OBJ_BY_NAME_I32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_LD_OBJ_BY_NAME_I32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_LD_OBJ_BY_NAME_I64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_LD_OBJ_BY_NAME_I64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_LD_OBJ_BY_NAME_F32:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_LD_OBJ_BY_NAME_F32 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_LD_OBJ_BY_NAME_F64:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_LD_OBJ_BY_NAME_F64 CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_EQUALS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE|compiler::inst_flags::NO_HOIST;
        constexpr auto SET_FLAGS = compiler::inst_flags::COMMUTATIVE;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_EQUALS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "COMPILER_ETS_EQUALS cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_STRICT_EQUALS:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE|compiler::inst_flags::NO_HOIST;
        constexpr auto SET_FLAGS = compiler::inst_flags::COMMUTATIVE;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_STRICT_EQUALS CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "COMPILER_ETS_STRICT_EQUALS cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_TYPEOF:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ|compiler::inst_flags::NO_DCE;
        constexpr auto SET_FLAGS = compiler::inst_flags::NO_NULLPTR;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_TYPEOF CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "COMPILER_ETS_TYPEOF cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_ISTRUE:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::ACC_READ|compiler::inst_flags::REQUIRE_STATE|compiler::inst_flags::CAN_THROW|compiler::inst_flags::HEAP_INV|compiler::inst_flags::NO_DCE|compiler::inst_flags::NO_CSE|compiler::inst_flags::NO_HOIST;
        constexpr auto SET_FLAGS = 0U;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_ISTRUE CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        break;
    }
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_NULLCHECK:
    {
        constexpr auto CLEAR_FLAGS = compiler::inst_flags::HEAP_INV|compiler::inst_flags::ACC_WRITE;
        constexpr auto SET_FLAGS = compiler::inst_flags::NO_NULLPTR;
        static_assert((SET_FLAGS & CLEAR_FLAGS) == 0, "COMPILER_ETS_NULLCHECK CLEAR_FLAGS cannot intersect SET_FLAGS");
        inst->ClearFlag(static_cast<inst_flags::Flags>(CLEAR_FLAGS));
        static_assert((SET_FLAGS & compiler::inst_flags::CAN_THROW) == 0 || (CLEAR_FLAGS & (compiler::inst_flags::REQUIRE_STATE | compiler::inst_flags::RUNTIME_CALL)) == 0, "COMPILER_ETS_NULLCHECK cannot set can_throw flag");
        inst->SetFlag(static_cast<inst_flags::Flags>(SET_FLAGS));
        break;
    }
#if defined(ENABLE_LIBABCKIT)
#include "dyn_intrinsics_flags.inc"
#endif
    default:
        return;
    }
}

inline bool IsIrtocIntrinsic(RuntimeInterface::IntrinsicId intrinsic)
{
    switch (intrinsic)
    {
    case RuntimeInterface::IntrinsicId::INTRINSIC_SLOW_PATH_ENTRY:
    case RuntimeInterface::IntrinsicId::INTRINSIC_SAVE_REGISTERS_EP:
    case RuntimeInterface::IntrinsicId::INTRINSIC_RESTORE_REGISTERS_EP:
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNREACHABLE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_TAIL_CALL:
    case RuntimeInterface::IntrinsicId::INTRINSIC_INTERPRETER_RETURN:
    case RuntimeInterface::IntrinsicId::INTRINSIC_INIT_INTERPRETER_CALL_RECORD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_PUSH_INTERPRETER_CALL_RECORD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_POP_INTERPRETER_CALL_RECORD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_POP_MULTIPLE_INTERPRETER_CALL_RECORDS:
    case RuntimeInterface::IntrinsicId::INTRINSIC_UPDATE_INTERPRETER_CALL_RECORD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_LOAD_ACQUIRE_MARK_WORD_EXCLUSIVE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STORE_RELEASE_MARK_WORD_EXCLUSIVE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPARE_AND_SET_MARK_WORD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_DATA_MEMORY_BARRIER_FULL:
    case RuntimeInterface::IntrinsicId::INTRINSIC_WRITE_TLAB_STATS_SAFE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_BYTES_U64:
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_BYTES_U32:
    case RuntimeInterface::IntrinsicId::INTRINSIC_REVERSE_HALF_WORDS:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COUNT_LEADING_ZERO_BITS_U64:
    case RuntimeInterface::IntrinsicId::INTRINSIC_EXPAND_U8_TO_U16:
    case RuntimeInterface::IntrinsicId::INTRINSIC_ATOMIC_BYTE_OR:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPRESS_EIGHT_UTF16_TO_UTF8_CHARS_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPRESS_SIXTEEN_UTF16_TO_UTF8_CHARS_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U8_X32_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U8_X16_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U16_X16_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_CHAR_U16_X8_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_LAST_CHAR_U16_X8_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_MEM_LAST_CHAR_U8_X16_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_UPPER_CASE_U8_X16_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_UPPER_CASE_U8_X8_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_LOWER_CASE_U8_X16_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_CHARS_TO_LOWER_CASE_U8_X8_USING_SIMD:
    case RuntimeInterface::IntrinsicId::INTRINSIC_JS_CAST_DOUBLE_TO_CHAR:
        return true;
    default:
        return false;
    }
}

inline bool IsFastpathIntrinsic(RuntimeInterface::IntrinsicId intrinsic)
{
    switch (intrinsic)  // NOLINT(hicpp-multiway-paths-covered)
    {
    default:
        return false;
    }
}

inline bool IsStackRangeIntrinsic(RuntimeInterface::IntrinsicId intrinsic, [[maybe_unused]] size_t *explicitArgs)
{
    switch (intrinsic) {  // NOLINT(hicpp-multiway-paths-covered)
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_CALL_FUNCTION:
        *explicitArgs = 3;
        return true;
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_CALL_VOID_FUNCTION:
        *explicitArgs = 3;
        return true;
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_JS_NEW_INSTANCE:
        *explicitArgs = 2;
        return true;
    default:
        return false;
    }
}

// Returns true if intrinsic is not a native call, but parameters are passed
// like in native calling convention
inline bool IntrinsicNeedsParamLocations([[maybe_unused]] RuntimeInterface::IntrinsicId intrinsic)
{
    // NOLINTNEXTLINE(hicpp-multiway-paths-covered)
    switch (intrinsic)
    {
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_MEMMOVE_UNCHECKED_1_BYTE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_MEMMOVE_UNCHECKED_2_BYTE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_MEMMOVE_UNCHECKED_4_BYTE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_MEMMOVE_UNCHECKED_8_BYTE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_END_NATIVE_METHOD_OBJ:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_GET_CHARS:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_GET_BYTES:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_EQUALS:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_INDEX_OF_AFTER:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_SUBSTRING:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_CONCAT2:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_CONCAT3:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_CONCAT4:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_STRING_COMPARE_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_WRITE_STRING:
    case RuntimeInterface::IntrinsicId::INTRINSIC_UNSAFE_MEMORY_READ_STRING:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BOOL_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_CHAR_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_BYTE_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_SHORT_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_INT_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_LONG_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_ESCOMPAT_OBJECT_FAST_COPY_TO_UNCHECKED:
    case RuntimeInterface::IntrinsicId::INTRINSIC_ESCOMPAT_OBJECT_FAST_COPY_TO_UNCHECKED_WITH_BARRIERS:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_FLOAT_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_CORE_DOUBLE_COPY_TO:
    case RuntimeInterface::IntrinsicId::INTRINSIC_STD_RUNTIME_GET_HASH_CODE_BY_VALUE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_ISTRUE:
    case RuntimeInterface::IntrinsicId::INTRINSIC_COMPILER_ETS_DOUBLE_TO_STRING_DECIMAL:
        return true;
    default:
        return false;
    }
}

inline bool IsIntrinsicInlinedByInputTypes([[maybe_unused]] RuntimeInterface::IntrinsicId intrinsic)
{
    return false;
}

